@pendle/core-v2 0.7.1-beta-2 → 0.8.0-beta-2

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -46,13 +46,13 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
 
     address public pendleYtCreationCodePointer;
 
-    uint256 public expiryDivisor;
-    uint256 public interestFeeRate;
-    address public treasury;
+    // 1 SLOT
+    uint128 public interestFeeRate; // a fixed point number
+    uint128 public rewardFeeRate; // a fixed point number
 
-    /// number of contracts that have been deployed from this address
-    /// must be increased everytime a new contract is deployed
-    uint256 public numContractDeployed;
+    // 1 SLOT
+    address public treasury;
+    uint96 public expiryDivisor;
 
     // SCY => expiry => address
     mapping(address => mapping(uint256 => address)) public getPT;
@@ -61,15 +61,16 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
     mapping(address => bool) public isYT;
 
     constructor(
-        uint256 _expiryDivisor,
-        uint256 _interestFeeRate,
+        uint96 _expiryDivisor,
+        uint128 _interestFeeRate,
+        uint128 _rewardFeeRate,
         address _treasury,
         address _governanceManager
     ) PermissionsV2Upg(_governanceManager) {
         setExpiryDivisor(_expiryDivisor);
         setInterestFeeRate(_interestFeeRate);
+        setRewardFeeRate(_rewardFeeRate);
         setTreasury(_treasury);
-        numContractDeployed++;
     }
 
     function initialize(bytes memory _pendleYtCreationCode) external initializer {
@@ -130,20 +131,25 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
         emit CreateYieldContract(SCY, PT, YT, expiry);
     }
 
-    function setExpiryDivisor(uint256 newExpiryDivisor) public onlyGovernance {
+    function setExpiryDivisor(uint96 newExpiryDivisor) public onlyGovernance {
         require(newExpiryDivisor != 0, "zero value");
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
-    function setInterestFeeRate(uint256 newInterestFeeRate) public onlyGovernance {
+    function setInterestFeeRate(uint128 newInterestFeeRate) public onlyGovernance {
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
+    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyGovernance {
+        rewardFeeRate = newInterestFeeRate;
+        emit SetInterestFeeRate(newInterestFeeRate);
+    }
+
     function setTreasury(address newTreasury) public onlyGovernance {
         require(newTreasury != address(0), "zero address");
         treasury = newTreasury;
-        emit SetTreasury(treasury);
+        emit SetTreasury(newTreasury);
     }
 }

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -13,20 +13,17 @@ import "../../interfaces/IPYieldContractFactory.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 import "../../libraries/RewardManagerAbstract.sol";
-import "../PendleERC20.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.
+/**
+Invariances to maintain:
+- address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
+    guaranteed by address(0) & address(this) check in each updateForTwo function
 */
 contract PendleYieldToken is
     IPYieldToken,
-    PendleERC20,
+    PendleERC20Permit,
     RewardManagerAbstract,
     InterestManagerYT
 {
@@ -34,10 +31,11 @@ contract PendleYieldToken is
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
 
-    struct AfterExpiryData {
-        bool isFinalized;
+    struct PostExpiryData {
         uint128 firstScyIndex;
-        uint256[] firstRewardIndexes;
+        uint128 totalScyInterestForTreasury;
+        mapping(address => uint256) firstRewardIndex;
+        mapping(address => uint256) userRewardOwed;
     }
 
     address public immutable SCY;
@@ -48,9 +46,10 @@ contract PendleYieldToken is
     uint128 public scyReserve;
     uint128 internal _scyIndexStored;
 
-    AfterExpiryData public afterExpiry;
+    PostExpiryData public postExpiry;
 
-    modifier updateScyReserve() {
+    modifier updateData() {
+        if (isExpired()) _setPostExpiryData();
         _;
         _updateScyReserve();
     }
@@ -62,7 +61,7 @@ contract PendleYieldToken is
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20(_name, _symbol, __decimals) {
+    ) PendleERC20Permit(_name, _symbol, __decimals) {
         SCY = _SCY;
         PT = _PT;
         expiry = _expiry;
@@ -73,7 +72,7 @@ contract PendleYieldToken is
     function mintPY(address receiverPT, address receiverYT)
         external
         nonReentrant
-        updateScyReserve
+        updateData
         returns (uint256 amountPYOut)
     {
         require(!isExpired(), "yield contract expired");
@@ -85,114 +84,109 @@ contract PendleYieldToken is
         _mint(receiverYT, amountPYOut);
 
         IPPrincipalToken(PT).mintByYT(receiverPT, amountPYOut);
-
-        emit Mint(msg.sender, receiverPT, receiverYT, 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
+        updateData
         returns (uint256 amountScyOut)
     {
         address[] memory receivers = new address[](1);
         uint256[] memory amounts = new uint256[](1);
-        (receivers[0], amounts[0]) = (receiver, type(uint256).max);
+        (receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());
 
-        (amountScyOut, ) = _redeemPY(receivers, amounts);
+        uint256[] memory amountScyOuts;
+        amountScyOuts = _redeemPY(receivers, amounts);
 
-        emit Redeem(msg.sender, receiver, amountScyOut);
+        amountScyOut = amountScyOuts[0];
     }
 
     /// @dev this function limit how much each receiver will receive. For example, if the totalOut is 100,
     /// and the max are 50 30 INF, the first receiver will receive 50, the second will receive 30, and the third will receive 20.
     /// @dev intended to mostly be used by Pendle router
-    function redeemPY(address[] memory receivers, uint256[] memory maxAmountScyOuts)
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
         nonReentrant
-        updateScyReserve
-        returns (uint256 totalAmountScyOut)
+        updateData
+        returns (uint256[] memory amountScyOuts)
     {
-        (totalAmountScyOut, ) = _redeemPY(receivers, maxAmountScyOuts);
+        require(receivers.length == amountPYToRedeems.length, "not same length");
+        require(receivers.length != 0, "empty array");
+        amountScyOuts = _redeemPY(receivers, amountPYToRedeems);
     }
 
     /**
-     * @dev _updateAndDistributeRewards must be called before every distributeInterest
-     */
-    function redeemDueInterestAndRewards(address user)
-        external
-        nonReentrant
-        updateScyReserve
-        returns (uint256 interestOut, uint256[] memory rewardsOut)
-    {
+    * @dev With YT yielding interest in the form of SCY, which is redeemable by users, the reward
+    distribution should be based on the amount of SCYs that their YT currently represent, plus their
+    dueInterest. It has been proven and tested that _rewardSharesUser will not change over time,
+    unless users redeem their dueInterest or redeemPY. Due to this, it is required to update users'
+    accruedReward STRICTLY BEFORE transferring out their interest.
+    */
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external nonReentrant updateData returns (uint256 interestOut, uint256[] memory rewardsOut) {
+        require(redeemInterest || redeemRewards, "nothing to redeem");
+
+        // if redeemRewards == true, this line must be here for obvious reason
+        // if redeemInterest == true, this line must be here because of the reason above
         _updateAndDistributeRewards(user);
-        _distributeInterest(user);
-        rewardsOut = _doTransferOutRewards(user, user);
-        interestOut = _doTransferOutInterest(user, SCY, factory);
 
-        emit RedeemRewards(user, rewardsOut);
-        emit RedeemInterest(user, interestOut);
+        if (redeemRewards) {
+            rewardsOut = _doTransferOutRewards(user, user);
+            emit RedeemRewards(user, rewardsOut);
+        } else {
+            address[] memory tokens = getRewardTokens();
+            rewardsOut = new uint256[](tokens.length);
+        }
+
+        if (redeemInterest) {
+            _distributeInterest(user);
+            interestOut = _doTransferOutInterest(user, SCY, factory);
+            emit RedeemInterest(user, interestOut);
+        } else {
+            interestOut = 0;
+        }
     }
 
-    /**
-     * @dev as mentioned in doc, _updateAndDistributeRewards should be placed strictly before every _distributeInterest
-     */
-    function redeemDueInterest(address user)
+    function redeemInterestAndRewardsPostExpiryForTreasury()
         external
         nonReentrant
-        updateScyReserve
-        returns (uint256 interestOut)
+        updateData
+        returns (uint256 interestOut, uint256[] memory rewardsOut)
     {
-        _updateAndDistributeRewards(user); /// strictly required, see above for explanation
-        _distributeInterest(user);
+        require(isExpired(), "not expired");
 
-        interestOut = _doTransferOutInterest(user, SCY, factory);
+        address treasury = IPYieldContractFactory(factory).treasury();
 
-        emit RedeemInterest(user, interestOut);
-    }
+        address[] memory tokens = getRewardTokens();
+        rewardsOut = new uint256[](tokens.length);
 
-    /// @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);
-    }
+        _redeemExternalReward();
 
-    /// @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);
+        for (uint256 i = 0; i < tokens.length; i++) {
+            rewardsOut[i] = _selfBalance(tokens[i]) - postExpiry.userRewardOwed[tokens[i]];
+        }
 
-        _redeemExternalReward();
+        _transferOut(tokens, treasury, rewardsOut);
 
-        rewardsOut = _selfBalances(rewardTokens).sub(preBalances);
-        _transferOut(rewardTokens, IPYieldContractFactory(factory).treasury(), rewardsOut);
+        interestOut = postExpiry.totalScyInterestForTreasury;
+        postExpiry.totalScyInterestForTreasury = 0;
+        _transferOut(SCY, treasury, interestOut);
     }
 
-    /// @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 = scyIndexCurrent().Uint128();
-        (, afterExpiry.firstRewardIndexes) = _updateRewardIndex();
+    function rewardIndexesCurrent() external override returns (uint256[] memory) {
+        return ISuperComposableYield(SCY).rewardIndexesCurrent();
     }
 
     /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
     function scyIndexCurrent() public returns (uint256 currentIndex) {
         currentIndex = Math.max(ISuperComposableYield(SCY).exchangeRate(), _scyIndexStored);
         _scyIndexStored = currentIndex.Uint128();
+        emit NewInterestIndex(currentIndex);
     }
 
     function scyIndexStored() public view returns (uint256) {
@@ -203,22 +197,55 @@ contract PendleYieldToken is
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
 
-    function _redeemPY(address[] memory receivers, uint256[] memory maxAmountScyOuts)
-        internal
-        returns (uint256 totalScyToReceivers, uint256 scyInterestAfterExpiry)
+    function getPostExpiryData()
+        external
+        view
+        returns (
+            uint256 firstScyIndex,
+            uint256 totalScyInterestForTreasury,
+            uint256[] memory firstRewardIndexes,
+            uint256[] memory userRewardOwed
+        )
     {
-        uint256 amountPYToRedeem = _getAmountPYToRedeem();
-        IPPrincipalToken(PT).burnByYT(address(this), amountPYToRedeem);
-        if (!isExpired()) _burn(address(this), amountPYToRedeem);
+        require(postExpiry.firstScyIndex != 0, "PostExpiry data not set");
 
-        (totalScyToReceivers, scyInterestAfterExpiry) = _calcScyRedeemableFromPY(amountPYToRedeem);
+        firstScyIndex = postExpiry.firstScyIndex;
+        totalScyInterestForTreasury = postExpiry.totalScyInterestForTreasury;
 
-        if (scyInterestAfterExpiry != 0) {
-            address treasury = IPYieldContractFactory(factory).treasury();
-            _transferOut(SCY, treasury, scyInterestAfterExpiry);
+        address[] memory tokens = getRewardTokens();
+        firstRewardIndexes = new uint256[](tokens.length);
+        userRewardOwed = new uint256[](tokens.length);
+
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            firstRewardIndexes[i] = postExpiry.firstRewardIndex[tokens[i]];
+            userRewardOwed[i] = postExpiry.userRewardOwed[tokens[i]];
         }
+    }
 
-        _transferOutMaxMulti(SCY, totalScyToReceivers, receivers, maxAmountScyOuts);
+    function _redeemPY(address[] memory receivers, uint256[] memory amountPYToRedeems)
+        internal
+        returns (uint256[] memory amountScyOuts)
+    {
+        uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();
+        IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
+        if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
+
+        uint256 index = scyIndexCurrent();
+        uint256 totalScyInterestPostExpiry;
+        amountScyOuts = new uint256[](receivers.length);
+
+        for (uint256 i = 0; i < receivers.length; i++) {
+            uint256 scyInterestPostExpiry;
+            (amountScyOuts[i], scyInterestPostExpiry) = _calcScyRedeemableFromPY(
+                amountPYToRedeems[i],
+                index
+            );
+            _transferOut(SCY, receivers[i], amountScyOuts[i]);
+            totalScyInterestPostExpiry += scyInterestPostExpiry;
+        }
+        if (totalScyInterestPostExpiry != 0) {
+            postExpiry.totalScyInterestForTreasury += totalScyInterestPostExpiry.Uint128();
+        }
     }
 
     function _calcPYToMint(uint256 amountScy) internal returns (uint256 amountPY) {
@@ -228,44 +255,59 @@ contract PendleYieldToken is
 
     function _calcScyRedeemableFromPY(uint256 amountPY)
         internal
-        returns (uint256 scyToUser, uint256 scyInterestAfterExpiry)
+        returns (uint256 scyToUser, uint256 scyInterestPostExpiry)
     {
+        return _calcScyRedeemableFromPY(amountPY, scyIndexCurrent());
+    }
+
+    function _calcScyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
+        internal
+        view
+        returns (uint256 scyToUser, uint256 scyInterestPostExpiry)
+    {
+        scyToUser = SCYUtils.assetToScy(indexCurrent, amountPY);
         if (isExpired()) {
-            finalizeAfterExpiryData();
-            uint256 totalScyRedeemable = SCYUtils.assetToScy(afterExpiry.firstScyIndex, amountPY);
-            scyToUser = SCYUtils.assetToScy(scyIndexCurrent(), amountPY);
-            scyInterestAfterExpiry = totalScyRedeemable - scyToUser;
-        } else {
-            scyToUser = SCYUtils.assetToScy(scyIndexCurrent(), amountPY);
+            uint256 totalScyRedeemable = SCYUtils.assetToScy(postExpiry.firstScyIndex, amountPY);
+            scyInterestPostExpiry = totalScyRedeemable - scyToUser;
         }
     }
 
     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));
+        if (!isExpired()) return Math.min(_selfBalance(PT), balanceOf(address(this)));
+        else return _selfBalance(PT);
     }
 
     function _updateScyReserve() internal virtual {
-        scyReserve = IERC20(SCY).balanceOf(address(this)).Uint128();
+        scyReserve = _selfBalance(SCY).Uint128();
     }
 
     function _getFloatingScyAmount() internal view returns (uint256 amount) {
-        amount = IERC20(SCY).balanceOf(address(this)) - scyReserve;
+        amount = _selfBalance(SCY) - scyReserve;
         require(amount > 0, "RECEIVE_ZERO");
     }
 
+    function _setPostExpiryData() internal {
+        PostExpiryData storage local = postExpiry;
+        if (local.firstScyIndex != 0) return; // already set
+
+        _redeemExternalReward(); // do a final redeem. All the future reward income will belong to the treasury
+
+        local.firstScyIndex = scyIndexCurrent().Uint128();
+        address[] memory rewardTokens = ISuperComposableYield(SCY).getRewardTokens();
+        uint256[] memory rewardIndexes = ISuperComposableYield(SCY).rewardIndexesCurrent();
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            local.firstRewardIndex[rewardTokens[i]] = rewardIndexes[i];
+            local.userRewardOwed[rewardTokens[i]] = _selfBalance(rewardTokens[i]);
+        }
+    }
+
     /*///////////////////////////////////////////////////////////////
                                INTEREST-RELATED
     //////////////////////////////////////////////////////////////*/
 
     function _getInterestIndex() internal virtual override returns (uint256 index) {
-        if (isExpired()) {
-            finalizeAfterExpiryData();
-            index = afterExpiry.firstScyIndex;
-        } else {
-            index = scyIndexCurrent();
-        }
+        if (isExpired()) index = postExpiry.firstScyIndex;
+        else index = scyIndexCurrent();
     }
 
     function _YTbalance(address user) internal view override returns (uint256) {
@@ -276,27 +318,49 @@ contract PendleYieldToken is
                                REWARDS-RELATED
     //////////////////////////////////////////////////////////////*/
 
+    function getRewardTokens() public view returns (address[] memory) {
+        return ISuperComposableYield(SCY).getRewardTokens();
+    }
+
     function _doTransferOutRewards(address user, address receiver)
         internal
         virtual
         override
         returns (uint256[] memory rewardAmounts)
     {
-        _redeemExternalReward();
+        address[] memory tokens = getRewardTokens();
 
-        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]);
-            }
+        if (isExpired()) {
+            // post-expiry, all incoming rewards will go to the treasury
+            // hence, we can save users one _redeemExternal here
+            for (uint256 i = 0; i < tokens.length; i++)
+                postExpiry.userRewardOwed[tokens[i]] -= userReward[tokens[i]][user].accrued;
+            rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver);
+        } else {
+            _redeemExternalReward();
+            rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver);
         }
     }
 
-    function getRewardTokens() external view returns (address[] memory) {
-        return _getRewardTokens();
+    function __doTransferOutRewardsLocal(
+        address[] memory tokens,
+        address user,
+        address receiver
+    ) internal returns (uint256[] memory rewardAmounts) {
+        address treasury = IPYieldContractFactory(factory).treasury();
+        uint256 feeRate = IPYieldContractFactory(factory).rewardFeeRate();
+
+        rewardAmounts = new uint256[](tokens.length);
+        for (uint256 i = 0; i < tokens.length; i++) {
+            uint256 rewardPreFee = userReward[tokens[i]][user].accrued;
+            userReward[tokens[i]][user].accrued = 0;
+
+            uint256 feeAmount = rewardPreFee.mulDown(feeRate);
+            rewardAmounts[i] = rewardPreFee - feeAmount;
+
+            _transferOut(tokens[i], treasury, feeAmount);
+            _transferOut(tokens[i], receiver, rewardAmounts[i]);
+        }
     }
 
     function _redeemExternalReward() internal virtual override {
@@ -310,40 +374,29 @@ contract PendleYieldToken is
         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();
+        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);
+            indexes = new uint256[](tokens.length);
+            for (uint256 i = 0; i < tokens.length; i++)
+                indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
         } else {
-            indexes = rewardIndexesCurrent();
+            indexes = ISuperComposableYield(SCY).rewardIndexesCurrent();
         }
     }
 
-    function rewardIndexesCurrent() public 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);
+        _setPostExpiryData();
         _updateAndDistributeRewardsForTwo(from, to);
+        _distributeInterestForTwo(from, to);
     }
 }

package/contracts/core/actions/ActionCallback.sol

@@ -3,7 +3,6 @@ pragma solidity 0.8.15;
 
 import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPMarketAddRemoveCallback.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/math/MarketApproxLib.sol";
@@ -93,9 +92,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         /// ------------------------------------------------------------
         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 totalScyNeed = scyIndex.assetToScyUp(ptOwed);
 
         /// ------------------------------------------------------------
         /// calc netScyToPull
@@ -116,24 +113,26 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
     /// @dev refer to _swapExactYtForScy or _swapYtForExactScy
     function _callbackSwapYtForScy(
         address market,
-        int256, /*ptToAccount*/
+        int256 ptToAccount,
         int256 scyToAccount,
         bytes calldata data
     ) internal {
         (address receiver, uint256 minScyOut) = _decodeSwapYtForScy(data);
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        SCYIndex scyIndex = SCY.newIndex();
 
         uint256 scyOwed = scyToAccount.neg().Uint();
 
         address[] memory receivers = new address[](2);
-        uint256[] memory amounts = new uint256[](2);
-
-        (receivers[0], amounts[0]) = (market, scyOwed);
-        (receivers[1], amounts[1]) = (receiver, type(uint256).max);
+        uint256[] memory amountPYToRedeems = new uint256[](2);
 
-        uint256 totalScyRedeemed = YT.redeemPY(receivers, amounts);
-        uint256 netScyOut = totalScyRedeemed - scyOwed;
+        (receivers[0], amountPYToRedeems[0]) = (market, scyIndex.scyToAssetUp(scyOwed));
+        (receivers[1], amountPYToRedeems[1]) = (
+            receiver,
+            ptToAccount.Uint() - amountPYToRedeems[0]
+        );
 
-        require(netScyOut >= minScyOut, "insufficient SCY out");
+        uint256[] memory amountScyOuts = YT.redeemPYMulti(receivers, amountPYToRedeems);
+        require(amountScyOuts[1] >= minScyOut, "insufficient SCY out");
     }
 }