@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/core/{PendleYieldContractFactory.sol → YieldContracts/PendleYieldContractFactory.sol}

@@ -21,27 +21,40 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
+
+import "../../interfaces/IPYieldContractFactory.sol";
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-import "../libraries/helpers/ExpiryUtilsLib.sol";
-import "../periphery/PermissionsV2Upg.sol";
-import "../interfaces/IPYieldContractFactory.sol";
+
+import "../../libraries/helpers/ExpiryUtilsLib.sol";
+import "../../libraries/solmate/LibRLP.sol";
+import "../../libraries/helpers/MiniDeployer.sol";
+import "../../libraries/helpers/MiniHelpers.sol";
+
+import "../../periphery/PermissionsV2Upg.sol";
 
 import "./PendlePrincipalToken.sol";
 import "./PendleYieldToken.sol";
 
-contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory {
+/// @dev If this contract is ever made upgradeable, please pay attention to the numContractDeployed variable
+contract PendleYieldContractFactory is PermissionsV2Upg, MiniDeployer, IPYieldContractFactory {
     using ExpiryUtils for string;
 
-    string public constant PT_PREFIX = "PT";
-    string public constant YT_PREFIX = "YT";
+    string private constant PT_PREFIX = "PT";
+    string private constant YT_PREFIX = "YT";
+
+    address public immutable pendleYtCreationCodePointer;
 
     uint256 public expiryDivisor;
     uint256 public interestFeeRate;
     address public treasury;
 
+    /// number of contracts that have been deployed from this address
+    /// must be increased everytime a new contract is deployed
+    uint256 public numContractDeployed;
+
     // SCY => expiry => address
     mapping(address => mapping(uint256 => address)) public getPT;
     mapping(address => mapping(uint256 => address)) public getYT;
@@ -52,36 +65,41 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
         uint256 _expiryDivisor,
         uint256 _interestFeeRate,
         address _treasury,
-        address _governanceManager
+        address _governanceManager,
+        bytes memory _pendleYtCreationCode
     ) PermissionsV2Upg(_governanceManager) {
-        require(_expiryDivisor != 0, "zero value");
-        require(_treasury != address(0), "zero address");
-
-        expiryDivisor = _expiryDivisor;
-        interestFeeRate = _interestFeeRate;
-        treasury = _treasury;
+        setExpiryDivisor(_expiryDivisor);
+        setInterestFeeRate(_interestFeeRate);
+        setTreasury(_treasury);
+        pendleYtCreationCodePointer = _setCreationCode(_pendleYtCreationCode);
+        numContractDeployed++;
     }
 
     /**
      * @notice Create a pair of (PT, YT) from any SCY and valid expiry. Anyone can create a yield contract
+     * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
      */
-    function createYieldContract(address SCY, uint256 expiry)
+    function createYieldContract(address SCY, uint32 expiry)
         external
         returns (address PT, address YT)
     {
-        require(expiry > block.timestamp, "invalid expiry");
+        require(!MiniHelpers.isTimeInThePast(expiry), "expiry must be in the future");
 
         require(expiry % expiryDivisor == 0, "must be multiple of divisor");
 
-        require(getPT[SCY][expiry] == address(0), "PT_EXISTED");
+        require(getPT[SCY][expiry] == address(0), "PT already existed");
 
         ISuperComposableYield _SCY = ISuperComposableYield(SCY);
 
-        uint8 assetDecimals = _SCY.assetDecimals();
+        (, , uint8 assetDecimals) = _SCY.assetInfo();
+
+        address predictedPTAddress = LibRLP.computeAddress(address(this), ++numContractDeployed);
+        address predictedYTAddress = LibRLP.computeAddress(address(this), ++numContractDeployed);
 
         PT = address(
             new PendlePrincipalToken(
                 SCY,
+                predictedYTAddress,
                 PT_PREFIX.concat(_SCY.name(), expiry, " "),
                 PT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
                 assetDecimals,
@@ -89,10 +107,13 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
             )
         );
 
-        YT = address(
-            new PendleYieldToken(
+        require(PT == predictedPTAddress, "IE predictedPTAddress");
+
+        YT = _deployWithArgs(
+            pendleYtCreationCodePointer,
+            abi.encode(
                 SCY,
-                PT,
+                predictedPTAddress,
                 YT_PREFIX.concat(_SCY.name(), expiry, " "),
                 YT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
                 assetDecimals,
@@ -100,7 +121,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
             )
         );
 
-        IPPrincipalToken(PT).initialize(YT);
+        require(YT == predictedYTAddress, "IE predictedYTAddress");
 
         getPT[SCY][expiry] = PT;
         getYT[SCY][expiry] = YT;
@@ -110,18 +131,18 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
         emit CreateYieldContract(SCY, PT, YT, expiry);
     }
 
-    function setExpiryDivisor(uint256 newExpiryDivisor) external onlyGovernance {
+    function setExpiryDivisor(uint256 newExpiryDivisor) public onlyGovernance {
         require(newExpiryDivisor != 0, "zero value");
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
-    function setInterestFeeRate(uint256 newInterestFeeRate) external onlyGovernance {
+    function setInterestFeeRate(uint256 newInterestFeeRate) public onlyGovernance {
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
-    function setTreasury(address newTreasury) external onlyGovernance {
+    function setTreasury(address newTreasury) public onlyGovernance {
         require(newTreasury != address(0), "zero address");
         treasury = newTreasury;
         emit SetTreasury(treasury);

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "../../interfaces/ISuperComposableYield.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import "../../libraries/math/Math.sol";
+import "../../libraries/helpers/ArrayLib.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../../libraries/SCY/SCYUtils.sol";
+import "../../libraries/helpers/MiniHelpers.sol";
+import "../../libraries/RewardManagerAbstract.sol";
+import "../PendleERC20Permit.sol";
+import "./InterestManagerYT.sol";
+
+/*
+With YT yielding more SCYs overtime, which is allowed to be redeemed by users, the reward distribution should
+be based on the amount of SCYs that their YT currently represent, plus with their dueInterest.
+
+It has been proven and tested that totalScyRedeemable will not change over time, unless users redeem their interest or redeemPY.
+
+Due to this, it is required to update users' accruedReward STRICTLY BEFORE redeeming their interest.
+*/
+contract PendleYieldToken is
+    IPYieldToken,
+    PendleERC20Permit,
+    RewardManagerAbstract,
+    InterestManagerYT
+{
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using ArrayLib for uint256[];
+
+    struct AfterExpiryData {
+        bool isFinalized;
+        uint128 firstScyIndex;
+        uint256[] firstRewardIndexes;
+    }
+
+    address public immutable SCY;
+    address public immutable PT;
+    address public immutable factory;
+    uint256 public immutable expiry;
+
+    uint256 public scyReserve;
+
+    AfterExpiryData public afterExpiry;
+
+    modifier updateScyReserve() {
+        _;
+        _updateScyReserve();
+    }
+
+    constructor(
+        address _SCY,
+        address _PT,
+        string memory _name,
+        string memory _symbol,
+        uint8 __decimals,
+        uint256 _expiry
+    ) PendleERC20Permit(_name, _symbol, __decimals) {
+        SCY = _SCY;
+        PT = _PT;
+        expiry = _expiry;
+        factory = msg.sender;
+    }
+
+    /**
+     * @notice this function splits scy into PT + YT of equal qty
+     * @dev the scy to tokenize has to be pre-transferred to this contract prior to the function call
+     */
+    function mintPY(address receiverPT, address receiverYT)
+        external
+        nonReentrant
+        updateScyReserve
+        returns (uint256 amountPYOut)
+    {
+        require(!isExpired(), "yield contract expired");
+
+        uint256 amountScyToMint = _getFloatingScyAmount();
+
+        amountPYOut = _calcPYToMint(amountScyToMint);
+
+        _mint(receiverYT, amountPYOut);
+
+        IPPrincipalToken(PT).mintByYT(receiverPT, amountPYOut);
+    }
+
+    /// @dev this function converts PY tokens into scy, but interests & rewards are not redeemed at the same time
+    function redeemPY(address receiver)
+        external
+        nonReentrant
+        updateScyReserve
+        returns (uint256 amountScyOut)
+    {
+        address[] memory receivers = new address[](1);
+        uint256[] memory amounts = new uint256[](1);
+        (receivers[0], amounts[0]) = (receiver, type(uint256).max);
+
+        (amountScyOut, ) = _redeemPY(receivers, amounts);
+    }
+
+    function redeemPY(address[] memory receivers, uint256[] memory amounts)
+        external
+        nonReentrant
+        updateScyReserve
+        returns (uint256 amountScyOut)
+    {
+        (amountScyOut, ) = _redeemPY(receivers, amounts);
+    }
+
+    /**
+     * @dev as mentioned in doc, updateDueReward should be placed strictly before every redeemDueInterest
+     */
+    function redeemDueInterestAndRewards(address user)
+        external
+        nonReentrant
+        updateScyReserve
+        returns (uint256 interestOut, uint256[] memory rewardsOut)
+    {
+        // redeemDueRewards before redeemDueInterest
+        _updateAndDistributeRewards(user);
+        _distributeInterest(user);
+        rewardsOut = _doTransferOutRewards(user, user);
+        interestOut = _doTransferOutInterest(user, SCY, factory);
+
+        emit RedeemRewards(user, rewardsOut);
+        emit RedeemInterest(user, interestOut);
+    }
+
+    /**
+     * @dev as mentioned in doc, _updateAndDistributeRewards should be placed strictly before every _distributeInterest
+     */
+    function redeemDueInterest(address user)
+        external
+        nonReentrant
+        updateScyReserve
+        returns (uint256 interestOut)
+    {
+        _updateAndDistributeRewards(user); /// strictly required, see above for explanation
+        _distributeInterest(user);
+
+        interestOut = _doTransferOutInterest(user, SCY, factory);
+
+        emit RedeemInterest(user, interestOut);
+    }
+
+    /// @dev no updateScyReserve since this function doesn't change the SCY reserve
+    function redeemDueRewards(address user)
+        external
+        nonReentrant
+        returns (uint256[] memory rewardsOut)
+    {
+        _updateAndDistributeRewards(user);
+        rewardsOut = _doTransferOutRewards(user, user);
+        emit RedeemRewards(user, rewardsOut);
+    }
+
+    /// @dev this function will only redeem rewards to the treasury, hence
+    /// no need to guard it with onlyGovernance
+    /// @dev no updateScyReserve since this function doesn't change the SCY reserve
+    function redeemRewardsAfterExpiryForTreasury()
+        external
+        nonReentrant
+        returns (uint256[] memory rewardsOut)
+    {
+        require(isExpired(), "not expired");
+        address[] memory rewardTokens = _getRewardTokens();
+        uint256[] memory preBalances = _selfBalances(rewardTokens);
+
+        _redeemExternalReward();
+
+        rewardsOut = _selfBalances(rewardTokens).sub(preBalances);
+        _transferOut(rewardTokens, IPYieldContractFactory(factory).treasury(), rewardsOut);
+    }
+
+    /// @notice can be called by anyone to lock in all the indexes
+    function finalizeAfterExpiryData() public {
+        if (!isExpired() || afterExpiry.isFinalized) return;
+        afterExpiry.isFinalized = true;
+        afterExpiry.firstScyIndex = ISuperComposableYield(SCY).exchangeRate().Uint128();
+        (, afterExpiry.firstRewardIndexes) = _updateRewardIndex();
+    }
+
+    /// @dev no reentrant & updateScyReserve since this function updates just the lastIndex
+    function getScyIndex() public view returns (uint256 currentIndex) {
+        return ISuperComposableYield(SCY).exchangeRate();
+    }
+
+    function isExpired() public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(expiry);
+    }
+
+    function _redeemPY(address[] memory receivers, uint256[] memory maxScyAmounts)
+        internal
+        returns (uint256 totalScyToReceivers, uint256 scyInterestAfterExpiry)
+    {
+        uint256 amountPYToRedeem = _getAmountPYToRedeem();
+        IPPrincipalToken(PT).burnByYT(address(this), amountPYToRedeem);
+        if (!isExpired()) _burn(address(this), amountPYToRedeem);
+
+        (totalScyToReceivers, scyInterestAfterExpiry) = _calcScyRedeemableFromPY(amountPYToRedeem);
+
+        if (scyInterestAfterExpiry != 0) {
+            address treasury = IPYieldContractFactory(factory).treasury();
+            _transferOut(SCY, treasury, scyInterestAfterExpiry);
+        }
+
+        _transferOutMaxMulti(SCY, totalScyToReceivers, receivers, maxScyAmounts);
+    }
+
+    function _calcPYToMint(uint256 amountScy) internal view returns (uint256 amountPY) {
+        // doesn't matter before or after expiry, since mintPY is only allowed before expiry
+        return SCYUtils.scyToAsset(getScyIndex(), amountScy);
+    }
+
+    function _calcScyRedeemableFromPY(uint256 amountPY)
+        internal
+        returns (uint256 scyToUser, uint256 scyInterestAfterExpiry)
+    {
+        if (isExpired()) {
+            finalizeAfterExpiryData();
+            uint256 totalScyRedeemable = SCYUtils.assetToScy(afterExpiry.firstScyIndex, amountPY);
+            scyToUser = SCYUtils.assetToScy(getScyIndex(), amountPY);
+            scyInterestAfterExpiry = totalScyRedeemable - scyToUser;
+        } else {
+            scyToUser = SCYUtils.assetToScy(getScyIndex(), amountPY);
+        }
+    }
+
+    function _getAmountPYToRedeem() internal view returns (uint256) {
+        if (!isExpired())
+            return Math.min(IERC20(PT).balanceOf(address(this)), balanceOf(address(this)));
+        else return IERC20(PT).balanceOf(address(this));
+    }
+
+    function _updateScyReserve() internal virtual {
+        scyReserve = IERC20(SCY).balanceOf(address(this)).Uint128();
+    }
+
+    function _getFloatingScyAmount() internal view returns (uint256 amount) {
+        amount = IERC20(SCY).balanceOf(address(this)) - scyReserve;
+        require(amount > 0, "RECEIVE_ZERO");
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               INTEREST-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _getInterestIndex() internal virtual override returns (uint256 index) {
+        if (isExpired()) {
+            finalizeAfterExpiryData();
+            index = afterExpiry.firstScyIndex;
+        } else {
+            index = ISuperComposableYield(SCY).exchangeRate();
+        }
+    }
+
+    function _YTbalance(address user) internal view override returns (uint256) {
+        return balanceOf(user);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _doTransferOutRewards(address user, address receiver)
+        internal
+        virtual
+        override
+        returns (uint256[] memory rewardAmounts)
+    {
+        _redeemExternalReward();
+
+        address[] memory tokens = _getRewardTokens();
+        rewardAmounts = new uint256[](tokens.length);
+        for (uint256 i = 0; i < tokens.length; i++) {
+            rewardAmounts[i] = userReward[tokens[i]][user].accrued;
+            if (rewardAmounts[i] != 0) {
+                userReward[tokens[i]][user].accrued = 0;
+                _transferOut(tokens[i], receiver, rewardAmounts[i]);
+            }
+        }
+    }
+
+    function getRewardTokens() external view returns (address[] memory) {
+        return _getRewardTokens();
+    }
+
+    function _redeemExternalReward() internal virtual override {
+        ISuperComposableYield(SCY).claimRewards(address(this)); // ignore return
+    }
+
+    /// @dev effectively returning the amount of SCY generating rewards for this user
+    function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
+        uint256 index = userInterest[user].index;
+        if (index == 0) return 0;
+        return SCYUtils.assetToScy(index, balanceOf(user)) + userInterest[user].accrued;
+    }
+
+    function _rewardSharesTotal() internal view virtual override returns (uint256) {
+        return scyReserve;
+    }
+
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return ISuperComposableYield(SCY).getRewardTokens();
+    }
+
+    function _updateRewardIndex()
+        internal
+        override
+        returns (address[] memory tokens, uint256[] memory indexes)
+    {
+        tokens = _getRewardTokens();
+        if (isExpired()) {
+            finalizeAfterExpiryData();
+            // padding to handle the very extreme case of SCY adding reward tokens after expiry
+            indexes = afterExpiry.firstRewardIndexes.padZeroRight(tokens.length);
+        } else {
+            indexes = ISuperComposableYield(SCY).rewardIndexesCurrent();
+        }
+    }
+
+    function rewardIndexesCurrent() external override returns (uint256[] memory) {
+        return ISuperComposableYield(SCY).rewardIndexesCurrent();
+    }
+
+    //solhint-disable-next-line ordering
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256
+    ) internal override {
+        _distributeInterestForTwo(from, to);
+        _updateAndDistributeRewardsForTwo(from, to);
+    }
+}

package/contracts/core/actions/ActionCallback.sol

@@ -1,23 +1,26 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketAddRemoveCallback.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
-import "../../SuperComposableYield/SCYUtils.sol";
+import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/math/MarketApproxLib.sol";
-import "../../libraries/math/MarketMathAux.sol";
 import "./base/ActionSCYAndPYBase.sol";
-import "./base/ActionType.sol";
+import "./base/CallbackHelper.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-contract ActionCallback is IPMarketSwapCallback, ActionType {
-    address public immutable marketFactory;
+contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
     using Math for int256;
     using Math for uint256;
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
+    using SafeERC20 for IERC20;
+    using SCYIndexLib for SCYIndex;
+    using SCYIndexLib for ISuperComposableYield;
+
+    address public immutable marketFactory;
 
     modifier onlyPendleMarket(address market) {
         require(IPMarketFactory(marketFactory).isValidMarket(market), "INVALID_MARKET");
@@ -38,82 +41,99 @@ contract ActionCallback is IPMarketSwapCallback, ActionType {
         int256 scyToAccount,
         bytes calldata data
     ) external override onlyPendleMarket(msg.sender) {
-        (ACTION_TYPE swapType, ) = abi.decode(data, (ACTION_TYPE, address));
-        if (swapType == ACTION_TYPE.SwapExactScyForYt) {
-            _swapExactScyForYt_callback(msg.sender, ptToAccount, scyToAccount, data);
-        } else if (swapType == ACTION_TYPE.SwapSCYForExactYt) {
-            _swapScyForExactYt_callback(msg.sender, ptToAccount, scyToAccount, data);
-        } else if (
-            swapType == ACTION_TYPE.SwapYtForExactScy || swapType == ACTION_TYPE.SwapExactYtForScy
-        ) {
-            _swapYtForScy_callback(msg.sender, ptToAccount, scyToAccount, data);
+        address market = msg.sender;
+        ActionType swapType = _getActionType(data);
+        if (swapType == ActionType.SwapExactScyForYt) {
+            _callbackSwapExactScyForYt(market, ptToAccount, scyToAccount, data);
+        } else if (swapType == ActionType.SwapScyForExactYt) {
+            _callbackSwapScyForExactYt(market, ptToAccount, scyToAccount, data);
+        } else if (swapType == ActionType.SwapYtForScy) {
+            _callbackSwapYtForScy(market, ptToAccount, scyToAccount, data);
         } else {
             require(false, "unknown swapType");
         }
     }
 
-    function _swapExactScyForYt_callback(
+    /// @dev refer to _swapExactScyForYt
+    function _callbackSwapExactScyForYt(
         address market,
         int256 ptToAccount,
         int256, /*scyToAccount*/
         bytes calldata data
     ) internal {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
-        (, address receiver) = abi.decode(data, (ACTION_TYPE, address));
+        (address receiver, uint256 minYtOut) = _decodeSwapExactScyForYt(data);
 
         uint256 ptOwed = ptToAccount.abs();
         uint256 amountPYout = YT.mintPY(market, receiver);
 
-        require(amountPYout >= ptOwed, "insufficient pt to pay");
+        require(amountPYout >= ptOwed, "insufficient PT to pay");
+        require(amountPYout >= minYtOut, "insufficient YT out");
     }
 
-    function _swapScyForExactYt_callback(
+    struct VarsSwapScyForExactYt {
+        address payer;
+        address receiver;
+        uint256 maxScyToPull;
+    }
+
+    /// @dev refer to _swapScyForExactYt
+    function _callbackSwapScyForExactYt(
         address market,
         int256 ptToAccount,
         int256 scyToAccount,
         bytes calldata data
     ) internal {
-        (, address payer, address receiver) = abi.decode(data, (ACTION_TYPE, address, address));
+        VarsSwapScyForExactYt memory vars;
+        (vars.payer, vars.receiver, vars.maxScyToPull) = _decodeSwapScyForExactYt(data);
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 ptOwed = ptToAccount.neg().Uint();
-        uint256 scyReceived = scyToAccount.Uint();
-
-        // ptOwed = totalAsset
-        uint256 scyIndex = SCY.scyIndexCurrent();
-        uint256 scyNeedTotal = SCYUtils.assetToScy(scyIndex, ptOwed);
-        scyNeedTotal += scyIndex.rawDivUp(SCYUtils.ONE);
+        /// ------------------------------------------------------------
+        /// calc totalScyNeed
+        /// ------------------------------------------------------------
+        SCYIndex scyIndex = SCY.newIndex();
+        uint256 ptOwed = ptToAccount.abs();
+        uint256 totalScyNeed = scyIndex.assetToScy(ptOwed);
+        // to guard against precision issue of lacking a few units of SCY. rawDivUp is not Fixed-Point division
+        totalScyNeed += SCYIndex.unwrap(scyIndex).rawDivUp(SCYUtils.ONE);
 
-        {
-            uint256 netScyToPull = scyNeedTotal.subMax0(scyReceived);
-            SCY.safeTransferFrom(payer, address(YT), netScyToPull);
-        }
+        /// ------------------------------------------------------------
+        /// calc netScyToPull
+        /// ------------------------------------------------------------
+        uint256 scyReceived = scyToAccount.Uint();
+        uint256 netScyToPull = totalScyNeed.subMax0(scyReceived);
+        require(netScyToPull <= vars.maxScyToPull, "exceed SCY in limit");
 
-        uint256 amountPYout = YT.mintPY(market, receiver);
+        /// ------------------------------------------------------------
+        /// mint & transfer
+        /// ------------------------------------------------------------
+        SCY.safeTransferFrom(vars.payer, address(YT), netScyToPull);
 
+        uint256 amountPYout = YT.mintPY(market, vars.receiver);
         require(amountPYout >= ptOwed, "insufficient pt to pay");
     }
 
-    /**
-    @dev receive PT -> pair with YT to redeem SCY -> payback SCY
-    */
-    function _swapYtForScy_callback(
+    /// @dev refer to _swapExactYtForScy or _swapYtForExactScy
+    function _callbackSwapYtForScy(
         address market,
         int256, /*ptToAccount*/
         int256 scyToAccount,
         bytes calldata data
     ) internal {
-        (, address receiver) = abi.decode(data, (ACTION_TYPE, address));
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (address receiver, uint256 minScyOut) = _decodeSwapYtForScy(data);
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 scyOwed = scyToAccount.neg().Uint();
 
-        uint256 netScyReceived = YT.redeemPY(address(this));
+        address[] memory receivers = new address[](2);
+        uint256[] memory amounts = new uint256[](2);
 
-        SCY.safeTransfer(market, scyOwed);
+        (receivers[0], amounts[0]) = (market, scyOwed);
+        (receivers[1], amounts[1]) = (receiver, type(uint256).max);
 
-        if (receiver != address(this)) {
-            SCY.safeTransfer(receiver, netScyReceived - scyOwed);
-        }
+        uint256 totalScyRedeemed = YT.redeemPY(receivers, amounts);
+        uint256 netScyOut = totalScyRedeemed - scyOwed;
+
+        require(netScyOut >= minScyOut, "insufficient SCY out");
     }
 }