@pendle/core-v2 3.0.0 → 4.0.1

package/contracts/router/ActionAddRemoveLiq.sol

@@ -1,525 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "./base/ActionBaseMintRedeem.sol";
-import "../interfaces/IPActionAddRemoveLiq.sol";
-import "../interfaces/IPMarket.sol";
-import "../core/libraries/Errors.sol";
-
-/**
- * @dev If market is expired, all actions will revert, except for the following:
- * - removeLiquidityDualSyAndPt()
- * - removeLiquidityDualTokenAndPt()
- * - removeLiquiditySingleSy()
- * - removeLiquiditySingleToken()
- * This is because swapping and adding liquidity are not allowed on an expired market.
- */
-contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
-    using PMath for uint256;
-    using PMath for int256;
-    using MarketMathCore for MarketState;
-    using MarketApproxPtInLib for MarketState;
-    using MarketApproxPtOutLib for MarketState;
-    using PYIndexLib for IPYieldToken;
-    using PYIndexLib for PYIndex;
-
-    /**
-     * @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`,
-     * while not changing the market's price
-     * @dev Only the necessary SY/PT amount will be transferred
-     * @dev Reverts if market is expired
-     */
-    function addLiquidityDualSyAndPt(
-        address receiver,
-        address market,
-        uint256 netSyDesired,
-        uint256 netPtDesired,
-        uint256 minLpOut
-    ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
-        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
-
-        // calculate the amount of SY and PT to be used
-        MarketState memory state = IPMarket(market).readState(address(this));
-        (, netLpOut, netSyUsed, netPtUsed) = state.addLiquidity(netSyDesired, netPtDesired, block.timestamp);
-
-        // early-check
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
-
-        // execute the addLiquidity
-        _transferFrom(IERC20(SY), msg.sender, market, netSyUsed);
-        _transferFrom(IERC20(PT), msg.sender, market, netPtUsed);
-
-        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
-
-        // fail-safe
-        if (netLpOut < minLpOut) assert(false);
-
-        emit AddLiquidityDualSyAndPt(msg.sender, market, receiver, netSyUsed, netPtUsed, netLpOut);
-    }
-
-    /**
-     * @notice Adds liquidity to SY/PT market using PT + any token.
-     * @dev Input token is first swapped to SY-mintable token using Kyber, then SY is minted from
-     * such. Finally the SY/PT pair is added to the market
-     * @param input data for input token, see {`./kyberswap/KyberSwapHelper.sol`}
-     * @param netPtDesired maximum PT to be used
-     * @dev Only the necessary PT amount will be transferred
-     * @dev All SY minted must be used, otherwise the call will revert. Therefore it is recommended
-     * that `netPtDesired` is slightly higher than actual expected.
-     * @dev Reverts if market is expired
-     */
-    function addLiquidityDualTokenAndPt(
-        address receiver,
-        address market,
-        TokenInput calldata input,
-        uint256 netPtDesired,
-        uint256 minLpOut
-    ) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed) {
-        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
-
-        uint256 netSyDesired = _mintSyFromToken(market, address(SY), 1, input);
-        uint256 netSyUsed;
-
-        {
-            // calc the amount of SY and PT to be used
-            MarketState memory state = IPMarket(market).readState(address(this));
-            (, netLpOut, netSyUsed, netPtUsed) = state.addLiquidity(netSyDesired, netPtDesired, block.timestamp);
-
-            if (netSyDesired != netSyUsed) revert Errors.RouterNotAllSyUsed(netSyDesired, netSyUsed);
-            if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
-
-            netTokenUsed = input.netTokenIn;
-        }
-
-        // SY has been minted and transferred to the market
-        _transferFrom(IERC20(PT), msg.sender, market, netPtUsed);
-        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
-
-        // fail-safe
-        if (netLpOut < minLpOut) assert(false);
-
-        emit AddLiquidityDualTokenAndPt(msg.sender, market, input.tokenIn, receiver, netTokenUsed, netPtUsed, netLpOut);
-    }
-
-    /**
-     * @notice Swaps partial PT to SY, then use them to add liquidity to SY/PT pair
-     * @param netPtIn amount of PT to be transferred in from caller
-     * @param guessPtSwapToSy approximate info for the swap
-     * @return netLpOut actual LP output, will not be lower than `minLpOut`
-     * @return netSyFee amount of SY fee incurred from the swap
-     * @dev Reverts if market is expired
-     */
-    function addLiquiditySinglePt(
-        address receiver,
-        address market,
-        uint256 netPtIn,
-        uint256 minLpOut,
-        ApproxParams calldata guessPtSwapToSy
-    ) external returns (uint256 netLpOut, uint256 netSyFee) {
-        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-
-        // calculate the amount of PT to swap
-        MarketState memory state = IPMarket(market).readState(address(this));
-
-        (uint256 netPtSwap, , ) = state.approxSwapPtToAddLiquidity(
-            YT.newIndex(),
-            netPtIn,
-            block.timestamp,
-            guessPtSwapToSy
-        );
-
-        // execute the swap
-        _transferFrom(IERC20(PT), msg.sender, market, netPtIn);
-
-        uint256 netSyReceived;
-        (netSyReceived, netSyFee) = IPMarket(market).swapExactPtForSy(market, netPtSwap, EMPTY_BYTES);
-
-        // execute the addLiquidity
-        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyReceived, netPtIn - netPtSwap);
-
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
-
-        emit AddLiquiditySinglePt(msg.sender, market, receiver, netPtIn, netLpOut);
-    }
-
-    /**
-     * @notice Swaps partial SY to PT, then use them to add liquidity to SY/PT pair
-     * @param netSyIn amount of SY to be transferred in from caller
-     * @param guessPtReceivedFromSy approx. output PT from the swap
-     * @return netLpOut actual LP output, will not be lower than `minLpOut`
-     * @return netSyFee amount of SY fee incurred from the swap
-     * @dev Reverts if market is expired
-     */
-    function addLiquiditySingleSy(
-        address receiver,
-        address market,
-        uint256 netSyIn,
-        uint256 minLpOut,
-        ApproxParams calldata guessPtReceivedFromSy
-    ) external returns (uint256 netLpOut, uint256 netSyFee) {
-        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        // transfer SY to market
-        _transferFrom(IERC20(SY), msg.sender, market, netSyIn);
-
-        // mint LP
-        (netLpOut, netSyFee) = _addLiquiditySingleSy(receiver, market, YT, netSyIn, minLpOut, guessPtReceivedFromSy);
-
-        emit AddLiquiditySingleSy(msg.sender, market, receiver, netSyIn, netLpOut);
-    }
-
-    /**
-     * @notice Adds liquidity using a single token input. The input token is first swapped through
-     * Kyberswap to a SY-mintable token, the rest is the same as `addLiquiditySingleSy()`
-     * @param guessPtReceivedFromSy approximate PT output for the SY-to-PT swap
-     * @param input data for input token, see {`./kyberswap/KyberSwapHelper.sol`}
-     * @return netLpOut actual LP output, will not be lower than `minLpOut`
-     * @return netSyFee amount of SY fee incurred from the swap
-     * @dev Reverts if market is expired
-     */
-    function addLiquiditySingleToken(
-        address receiver,
-        address market,
-        uint256 minLpOut,
-        ApproxParams calldata guessPtReceivedFromSy,
-        TokenInput calldata input
-    ) external payable returns (uint256 netLpOut, uint256 netSyFee) {
-        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        // mint SY directly to the market
-        uint256 netSyUsed = _mintSyFromToken(market, address(SY), 1, input);
-
-        // mint LP
-        (netLpOut, netSyFee) = _addLiquiditySingleSy(receiver, market, YT, netSyUsed, minLpOut, guessPtReceivedFromSy);
-
-        emit AddLiquiditySingleToken(msg.sender, market, input.tokenIn, receiver, input.netTokenIn, netLpOut);
-    }
-
-    /**
-     * @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
-     * @dev Will work even if market is expired
-     */
-    function removeLiquidityDualSyAndPt(
-        address receiver,
-        address market,
-        uint256 netLpToRemove,
-        uint256 minSyOut,
-        uint256 minPtOut
-    ) external returns (uint256 netSyOut, uint256 netPtOut) {
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
-
-        (netSyOut, netPtOut) = IPMarket(market).burn(receiver, receiver, netLpToRemove);
-
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
-
-        emit RemoveLiquidityDualSyAndPt(msg.sender, market, receiver, netLpToRemove, netPtOut, netSyOut);
-    }
-
-    /**
-     * @notice Burns LP token to remove SY/PT liquidity, then redeems SY, finally (if needed)
-     * swaps SY redeemings through Kyberswap to desired output token.
-     * @param netLpToRemove amount of LP to be burned from caller
-     * @param output data for desired output token, see {`./kyberswap/KyberSwapHelper.sol`}
-     * @dev Will work even if market is expired
-     */
-    function removeLiquidityDualTokenAndPt(
-        address receiver,
-        address market,
-        uint256 netLpToRemove,
-        TokenOutput calldata output,
-        uint256 minPtOut
-    ) external returns (uint256 netTokenOut, uint256 netPtOut) {
-        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
-
-        // burn LP, SY sent to either SY or bulk, PT sent to receiver
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
-
-        uint256 netSyOut;
-        (netSyOut, netPtOut) = IPMarket(market).burn(_syOrBulk(address(SY), output), receiver, netLpToRemove);
-
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
-
-        // redeem SY to token
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
-
-        emit RemoveLiquidityDualTokenAndPt(
-            msg.sender,
-            market,
-            output.tokenOut,
-            receiver,
-            netLpToRemove,
-            netPtOut,
-            netTokenOut
-        );
-    }
-
-    /**
-     * @notice Removes SY/PT liquidity, then swaps all resulting SY to return only PT
-     * @param netLpToRemove amount of LP to be burned from caller
-     * @param guessPtReceivedFromSy approximate info for the swap
-     * @return netPtOut total PT output, will not be lower than `minPtOut`
-     * @return netSyFee amount of SY fee incurred from the swap
-     * @dev Reverts if market is expired
-     */
-    function removeLiquiditySinglePt(
-        address receiver,
-        address market,
-        uint256 netLpToRemove,
-        uint256 minPtOut,
-        ApproxParams calldata guessPtReceivedFromSy
-    ) external returns (uint256 netPtOut, uint256 netSyFee) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        // calculate the total amount of PT received from burning & selling SY
-        MarketState memory state = IPMarket(market).readState(address(this));
-        (uint256 syFromBurn, uint256 ptFromBurn) = state.removeLiquidity(netLpToRemove);
-        (uint256 ptFromSwap, ) = state.approxSwapExactSyForPt(
-            YT.newIndex(),
-            syFromBurn,
-            block.timestamp,
-            guessPtReceivedFromSy
-        );
-
-        if (ptFromBurn + ptFromSwap < minPtOut)
-            revert Errors.RouterInsufficientPtOut(ptFromBurn + ptFromSwap, minPtOut);
-
-        // execute the burn & the swap
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
-
-        (, ptFromBurn) = IPMarket(market).burn(market, receiver, netLpToRemove);
-        (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, ptFromSwap, EMPTY_BYTES);
-
-        netPtOut = ptFromBurn + ptFromSwap;
-
-        // fail-safe
-        if (netPtOut < minPtOut) assert(false);
-
-        emit RemoveLiquiditySinglePt(msg.sender, market, receiver, netLpToRemove, netPtOut);
-    }
-
-    /**
-     * @notice Removes SY/PT liquidity, then converts all resulting PT to return only SY
-     * @dev Conversion is done with market swap if not expired, or with PT redeeming if expired
-     * @param netLpToRemove amount of LP to be burned from caller
-     * @return netSyOut total SY output, will not be lower than `minSyOut`
-     * @return netSyFee amount of SY fee incurred from the swap
-     * @dev Will work even if market is expired
-     */
-    function removeLiquiditySingleSy(
-        address receiver,
-        address market,
-        uint256 netLpToRemove,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut, uint256 netSyFee) {
-        // transfer LP to market
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
-
-        // burn LP, SY sent to receiver
-        (netSyOut, netSyFee) = _removeLiquiditySingleSy(receiver, market, netLpToRemove, minSyOut);
-
-        emit RemoveLiquiditySingleSy(msg.sender, market, receiver, netLpToRemove, netSyOut);
-    }
-
-    /**
-     * @notice Removes SY/PT liquidity, then converts all to desired output token.
-     * @dev inner workings of this function:
-        - Removes SY/PT liquidity to only SY (see `removeLiquiditySingleSy()`)
-        - Burns SY to redeem SY-mintable tokens
-        - (If needed) swaps resulting tokens to desired output token using Kyberswap
-     * @param netLpToRemove amount of LP to be burned from caller
-     * @param output data for desired output token, see {`./kyberswap/KyberSwapHelper.sol`}
-     * @return netTokenOut total token output, will not be lower than `output.minTokenOut`
-     * @return netSyFee amount of SY fee incurred from the swap
-     * @dev Will work even if market is expired
-     */
-    function removeLiquiditySingleToken(
-        address receiver,
-        address market,
-        uint256 netLpToRemove,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netSyFee) {
-        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
-
-        // transfer LP to market, burn LP, SY sent to either SY or bulk
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
-
-        uint256 netSyReceived;
-
-        (netSyReceived, netSyFee) = _removeLiquiditySingleSy(_syOrBulk(address(SY), output), market, netLpToRemove, 1);
-
-        // redeem SY to token
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyReceived, output, false);
-
-        emit RemoveLiquiditySingleToken(msg.sender, market, output.tokenOut, receiver, netLpToRemove, netTokenOut);
-    }
-
-    /// @dev swaps SY to PT, then adds liquidity
-    function _addLiquiditySingleSy(
-        address receiver,
-        address market,
-        IPYieldToken YT,
-        uint256 netSyIn,
-        uint256 minLpOut,
-        ApproxParams calldata guessPtReceivedFromSy
-    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
-        MarketState memory state = IPMarket(market).readState(address(this));
-
-        // calculate the PT amount needed to add liquidity
-        (uint256 netPtFromSwap, , ) = state.approxSwapSyToAddLiquidity(
-            YT.newIndex(),
-            netSyIn,
-            block.timestamp,
-            guessPtReceivedFromSy
-        );
-
-        // execute the swap & the addLiquidity
-        uint256 netSySwapped;
-        (netSySwapped, netSyFee) = IPMarket(market).swapSyForExactPt(market, netPtFromSwap, EMPTY_BYTES);
-
-        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyIn - netSySwapped, netPtFromSwap);
-
-        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,
-        address market,
-        uint256 netLpToRemove,
-        uint256 minSyOut
-    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        if (IPMarket(market).isExpired()) {
-            netSyOut = __removeLpToSyAfterExpiry(receiver, market, netLpToRemove);
-        } else {
-            (netSyOut, netSyFee) = __removeLpToSyBeforeExpiry(receiver, market, netLpToRemove);
-        }
-
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
-    }
-
-    /// @dev converts PT to SY post-expiry
-    function __removeLpToSyAfterExpiry(
-        address receiver,
-        address market,
-        uint256 netLpToRemove
-    ) internal returns (uint256 netSyOut) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-        (uint256 syFromBurn, ) = IPMarket(market).burn(receiver, address(YT), netLpToRemove);
-        netSyOut = syFromBurn + YT.redeemPY(receiver);
-    }
-
-    /// @dev swaps PT to SY pre-expiry
-    function __removeLpToSyBeforeExpiry(
-        address receiver,
-        address market,
-        uint256 netLpToRemove
-    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        (uint256 syFromBurn, uint256 ptFromBurn) = IPMarket(market).burn(receiver, market, netLpToRemove);
-
-        uint256 syFromSwap;
-        (syFromSwap, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, ptFromBurn, EMPTY_BYTES);
-
-        netSyOut = syFromBurn + syFromSwap;
-    }
-}

package/contracts/router/ActionMintRedeem.sol

@@ -1,134 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "./base/ActionBaseMintRedeem.sol";
-import "../interfaces/IPMarket.sol";
-import "../interfaces/IPActionMintRedeem.sol";
-import "../core/libraries/Errors.sol";
-
-contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
-    using MarketMathCore for MarketState;
-    using PMath for uint256;
-    using PMath for int256;
-
-    /**
-     * @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`}
-     */
-    function mintSyFromToken(
-        address receiver,
-        address SY,
-        uint256 minSyOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netSyOut) {
-        netSyOut = _mintSyFromToken(receiver, SY, minSyOut, input);
-        emit MintSyFromToken(msg.sender, input.tokenIn, SY, receiver, input.netTokenIn, netSyOut);
-    }
-
-    /**
-     * @notice redeems SY for SY-mintable tokens, then (if needed) swaps resulting tokens for
-     * desired output token through Kyberswap
-     * @param output data for desired output token, see {`./kyberswap/KyberSwapHelper.sol`}
-     */
-    function redeemSyToToken(
-        address receiver,
-        address SY,
-        uint256 netSyIn,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut) {
-        netTokenOut = _redeemSyToToken(receiver, SY, netSyIn, output, true);
-        emit RedeemSyToToken(msg.sender, output.tokenOut, SY, receiver, netSyIn, netTokenOut);
-    }
-
-    /**
-     * @notice mints PY from any input token
-     * @dev swaps input token through Kyberswap to SY-mintable tokens first, then mints SY, finally
-     * mints PY from SY
-     * @param input data for input token, see {`./kyberswap/KyberSwapHelper.sol`}
-     * @dev reverts if PY is expired
-     */
-    function mintPyFromToken(
-        address receiver,
-        address YT,
-        uint256 minPyOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netPyOut) {
-        address SY = IPYieldToken(YT).SY();
-
-        uint256 netSyToMint = _mintSyFromToken(YT, SY, 0, input);
-        netPyOut = _mintPyFromSy(receiver, SY, YT, netSyToMint, minPyOut, false);
-
-        emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut);
-    }
-
-    /**
-     * @notice redeems PY for token
-     * @dev redeems PT(+YT) for SY first, then redeems SY, finally swaps resulting tokens to output
-     * token through Kyberswap (if needed)
-     * @param output data for desired output token, see {`./kyberswap/KyberSwapHelper.sol`}
-     */
-    function redeemPyToToken(
-        address receiver,
-        address YT,
-        uint256 netPyIn,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut) {
-        address SY = IPYieldToken(YT).SY();
-
-        uint256 netSyToRedeem = _redeemPyToSy(_syOrBulk(SY, output), YT, netPyIn, 1);
-        netTokenOut = _redeemSyToToken(receiver, SY, netSyToRedeem, output, false);
-
-        emit RedeemPyToToken(msg.sender, output.tokenOut, YT, receiver, netPyIn, netTokenOut);
-    }
-
-    /**
-     * @notice mints PT+YT from input SY
-     * @dev reverts if the PY pair is expired
-     */
-    function mintPyFromSy(
-        address receiver,
-        address YT,
-        uint256 netSyIn,
-        uint256 minPyOut
-    ) external returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromSy(receiver, IPYieldToken(YT).SY(), YT, netSyIn, minPyOut, true);
-        emit MintPyFromSy(msg.sender, receiver, YT, netSyIn, netPyOut);
-    }
-
-    /// @notice redeems PT(+YT) for its corresponding SY
-    function redeemPyToSy(
-        address receiver,
-        address YT,
-        uint256 netPyIn,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut) {
-        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut);
-        emit RedeemPyToSy(msg.sender, receiver, YT, netPyIn, netSyOut);
-    }
-
-    /**
-     * @notice A unified interface for redeeming rewards and interests for any SYs,
-     * YTs, and markets alike for `user`.
-     * @dev returns arrays of amounts claimed for each asset.
-     */
-    function redeemDueInterestAndRewards(
-        address user,
-        address[] calldata sys,
-        address[] calldata yts,
-        address[] calldata markets
-    ) external {
-        unchecked {
-            for (uint256 i = 0; i < sys.length; ++i) {
-                IStandardizedYield(sys[i]).claimRewards(user);
-            }
-
-            for (uint256 i = 0; i < yts.length; ++i) {
-                IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
-            }
-
-            for (uint256 i = 0; i < markets.length; ++i) {
-                IPMarket(markets[i]).redeemRewards(user);
-            }
-        }
-    }
-}