@pendle/core-v2 0.2.3 → 0.4.0

package/contracts/SuperComposableYield/ISuperComposableYield.sol

@@ -25,15 +25,29 @@ pragma solidity 0.8.9;
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 interface ISuperComposableYield is IERC20Metadata {
+    function mintNoPull(
+        address receiver,
+        address baseTokenIn,
+        uint256 minAmountScyOut
+    ) external returns (uint256 amountScyOut);
+
+    function redeemNoPull(
+        address receiver,
+        address baseTokenOut,
+        uint256 minAmountBaseOut
+    ) external returns (uint256 amountBaseOut);
+
     function mint(
         address receiver,
         address baseTokenIn,
+        uint256 amountBaseToPull,
         uint256 minAmountScyOut
     ) external returns (uint256 amountScyOut);
 
     function redeem(
         address receiver,
         address baseTokenOut,
+        uint256 amountScyToPull,
         uint256 minAmountBaseOut
     ) external returns (uint256 amountBaseOut);
 
@@ -41,11 +55,7 @@ interface ISuperComposableYield is IERC20Metadata {
 
     function updateUserReward(address user) external;
 
-    /// @notice if user == msg.sender, receiver can be any addresses
-    /// else, receiver must be msg.sender
-    function redeemReward(address user, address receiver)
-        external
-        returns (uint256[] memory outAmounts);
+    function redeemReward(address user) external returns (uint256[] memory outAmounts);
 
     /**
     * @notice scyIndexCurrent.mulDown(scyBalance) must return the asset balance of the account

package/contracts/SuperComposableYield/implementations/RewardManager.sol

@@ -2,11 +2,11 @@
 pragma solidity 0.8.9;
 import "../ISuperComposableYield.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../libraries/math/FixedPoint.sol";
+import "../../libraries/math/Math.sol";
 
 abstract contract RewardManager {
     using SafeERC20 for IERC20;
-    using FixedPoint for uint256;
+    using Math for uint256;
 
     struct GlobalReward {
         uint256 index;

package/contracts/SuperComposableYield/implementations/SCYBase.sol

@@ -4,7 +4,7 @@ import "../ISuperComposableYield.sol";
 import "./RewardManager.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "../../libraries/math/FixedPoint.sol";
+import "../../libraries/math/Math.sol";
 import "../SCYUtils.sol";
 
 /**
@@ -15,7 +15,7 @@ satisfy this restriction is AaveV2's aToken
 */
 abstract contract SCYBase is ERC20, ISuperComposableYield {
     using SafeERC20 for IERC20;
-    using FixedPoint for uint256;
+    using Math for uint256;
 
     uint8 private immutable _scyDecimals;
     uint8 private immutable _assetDecimals;
@@ -37,6 +37,26 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
     //////////////////////////////////////////////////////////////*/
 
     function mint(
+        address receiver,
+        address baseTokenIn,
+        uint256 amountBaseToPull,
+        uint256 minAmountScyOut
+    ) external returns (uint256 amountScyOut) {
+        IERC20(baseTokenIn).safeTransferFrom(msg.sender, address(this), amountBaseToPull);
+        amountScyOut = mintNoPull(receiver, baseTokenIn, minAmountScyOut);
+    }
+
+    function redeem(
+        address receiver,
+        address baseTokenOut,
+        uint256 amountScyToPull,
+        uint256 minAmountBaseOut
+    ) external returns (uint256 amountBaseOut) {
+        transferFrom(msg.sender, address(this), amountScyToPull);
+        amountBaseOut = redeemNoPull(receiver, baseTokenOut, minAmountBaseOut);
+    }
+
+    function mintNoPull(
         address receiver,
         address baseTokenIn,
         uint256 minAmountScyOut
@@ -52,7 +72,7 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
         _mint(receiver, amountScyOut);
     }
 
-    function redeem(
+    function redeemNoPull(
         address receiver,
         address baseTokenOut,
         uint256 minAmountBaseOut

package/contracts/SuperComposableYield/implementations/SCYBaseWithRewards.sol

@@ -5,7 +5,7 @@ import "./RewardManager.sol";
 import "./SCYBase.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "../../libraries/math/FixedPoint.sol";
+import "../../libraries/math/Math.sol";
 
 /**
 # CONDITIONS TO USE THIS PRESET:
@@ -15,7 +15,7 @@ satisfy this restriction is AaveV2's aToken
 */
 abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
     using SafeERC20 for IERC20;
-    using FixedPoint for uint256;
+    using Math for uint256;
 
     constructor(
         string memory _name,
@@ -34,17 +34,14 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
                                REWARDS-RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function redeemReward(address user, address receiver)
+    function redeemReward(address user)
         public
         virtual
         override
         returns (uint256[] memory outAmounts)
     {
-        if (user != msg.sender) require(receiver == user, "invalid receiver");
-        else require(receiver != address(0), "zero address");
-
         _updateUserReward(user, balanceOf(user), totalSupply());
-        outAmounts = _doTransferOutRewardsForUser(user, receiver);
+        outAmounts = _doTransferOutRewardsForUser(user, user);
     }
 
     function updateGlobalReward() public virtual override {

package/contracts/core/PendleMarket.sol

@@ -10,19 +10,20 @@ import "../interfaces/IPMarketSwapCallback.sol";
 import "../interfaces/IPMarketAddRemoveCallback.sol";
 
 import "../libraries/math/LogExpMath.sol";
-import "../libraries/math/FixedPoint.sol";
-import "../libraries/math/MarketMathLib.sol";
+import "../libraries/math/Math.sol";
+import "../libraries/math/MarketMathAux.sol";
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 
 // solhint-disable reason-string
 contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
-    using FixedPoint for uint256;
-    using FixedPoint for int256;
-    using FixedPoint for uint128;
+    using Math for uint256;
+    using Math for int256;
+    using Math for uint128;
     using LogExpMath for uint256;
-    using MarketMathLib for MarketParameters;
+    using MarketMathAux for MarketState;
+    using MarketMathCore for MarketState;
     using SafeERC20 for IERC20;
 
     string private constant NAME = "Pendle Market";
@@ -75,14 +76,15 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
             uint256 otUsed
         )
     {
-        MarketParameters memory market = readState();
+        MarketState memory market = readState(true);
         SCYIndex index = SCYIndexLib.newIndex(SCY);
 
         uint256 lpToReserve;
         (lpToReserve, lpToAccount, scyUsed, otUsed) = market.addLiquidity(
             index,
             scyDesired,
-            otDesired
+            otDesired,
+            true
         );
 
         // initializing the market
@@ -113,9 +115,9 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         uint256 lpToRemove,
         bytes calldata data
     ) external nonReentrant returns (uint256 scyToAccount, uint256 otToAccount) {
-        MarketParameters memory market = readState();
+        MarketState memory market = readState(true);
 
-        (scyToAccount, otToAccount) = market.removeLiquidity(lpToRemove);
+        (scyToAccount, otToAccount) = market.removeLiquidity(lpToRemove, true);
 
         IERC20(SCY).safeTransfer(receiver, scyToAccount);
         IERC20(OT).safeTransfer(receiver, otToAccount);
@@ -142,12 +144,13 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
     ) external nonReentrant returns (uint256 netScyOut, uint256 netScyToReserve) {
         require(block.timestamp < expiry, "MARKET_EXPIRED");
 
-        MarketParameters memory market = readState();
+        MarketState memory market = readState(true);
 
         (netScyOut, netScyToReserve) = market.swapExactOtForScy(
             SCYIndexLib.newIndex(SCY),
             exactOtIn,
-            block.timestamp
+            block.timestamp,
+            true
         );
         require(netScyOut >= minScyOut, "insufficient scy out");
         IERC20(SCY).safeTransfer(receiver, netScyOut);
@@ -170,12 +173,13 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
     ) external nonReentrant returns (uint256 netScyIn, uint256 netScyToReserve) {
         require(block.timestamp < expiry, "MARKET_EXPIRED");
 
-        MarketParameters memory market = readState();
+        MarketState memory market = readState(true);
 
         (netScyIn, netScyToReserve) = market.swapScyForExactOt(
             SCYIndexLib.newIndex(SCY),
             exactOtOut,
-            block.timestamp
+            block.timestamp,
+            true
         );
         require(netScyIn <= maxScyIn, "scy in exceed limit");
         IERC20(OT).safeTransfer(receiver, exactOtOut);
@@ -193,14 +197,10 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
     /// @dev this function is just a place holder. Later on the rewards will be transferred to the liquidity minining
     /// instead
     function redeemScyReward() external returns (uint256[] memory outAmounts) {
-        outAmounts = ISuperComposableYield(SCY).redeemReward(
-            address(this),
-            IPMarketFactory(factory).treasury()
-        );
+        outAmounts = ISuperComposableYield(SCY).redeemReward(address(this));
     }
 
-    /// the only non-view part in this function is the ISuperComposableYield(SCY).scyIndexCurrent()
-    function readState() public view returns (MarketParameters memory market) {
+    function readState(bool updateRateOracle) public view returns (MarketState memory market) {
         MarketStorage storage store = marketStorage;
         market.totalOt = store.totalOt;
         market.totalScy = store.totalScy;
@@ -216,10 +216,12 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         market.lastImpliedRate = store.lastImpliedRate;
         market.lastTradeTime = store.lastTradeTime;
 
-        market.updateNewRateOracle(block.timestamp);
+        if (updateRateOracle) {
+            market.updateNewRateOracle(block.timestamp);
+        }
     }
 
-    function _writeState(MarketParameters memory market) internal {
+    function _writeState(MarketState memory market) internal {
         MarketStorage storage store = marketStorage;
 
         store.totalOt = market.totalOt.Int128();

package/contracts/core/PendleMarketFactory.sol

@@ -4,18 +4,19 @@ import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
-import "../periphery/PermissionsV2.sol";
+import "../periphery/PermissionsV2Upg.sol";
 import "./PendleMarket.sol";
 
-contract PendleMarketFactory is PermissionsV2, IPMarketFactory {
+contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    mapping(address => EnumerableSet.AddressSet) internal otMarkets;
+    mapping(address => EnumerableSet.AddressSet) internal markets;
+
     address public immutable yieldContractFactory;
     address public treasury;
 
     constructor(address _governanceManager, address _yieldContractFactory)
-        PermissionsV2(_governanceManager)
+        PermissionsV2Upg(_governanceManager)
     {
         yieldContractFactory = _yieldContractFactory;
     }
@@ -46,7 +47,7 @@ contract PendleMarketFactory is PermissionsV2, IPMarketFactory {
                 reserveFeePercent
             )
         );
-        otMarkets[address(OT)].add(market);
+        markets[OT].add(market);
     }
 
     function setTreasury(address newTreasury) external onlyGovernance {
@@ -55,6 +56,6 @@ contract PendleMarketFactory is PermissionsV2, IPMarketFactory {
 
     function isValidMarket(address market) external view returns (bool) {
         address OT = IPMarket(market).OT();
-        return otMarkets[OT].contains(market);
+        return markets[OT].contains(market);
     }
 }

package/contracts/core/PendleSCYImpl/PendleBenQiErc20SCY.sol

@@ -80,7 +80,7 @@ contract PendleBenQiErc20SCY is SCYBaseWithRewards {
     //////////////////////////////////////////////////////////////*/
 
     function scyIndexCurrent() public virtual override returns (uint256 res) {
-        res = FixedPoint.max(lastScyIndex, IQiToken(qiToken).exchangeRateCurrent());
+        res = Math.max(lastScyIndex, IQiToken(qiToken).exchangeRateCurrent());
         lastScyIndex = res;
         return res;
     }

package/contracts/core/PendleSCYImpl/PendleBtrflySCY.sol

@@ -74,7 +74,7 @@ contract PendleBtrflyScy is SCYBase {
     //////////////////////////////////////////////////////////////*/
 
     function scyIndexCurrent() public virtual override returns (uint256 res) {
-        res = FixedPoint.max(lastScyIndex, IWXBTRFLY(wxBTRFLY).xBTRFLYValue(FixedPoint.ONE));
+        res = Math.max(lastScyIndex, IWXBTRFLY(wxBTRFLY).xBTRFLYValue(Math.ONE));
         lastScyIndex = res;
         return res;
     }
@@ -103,12 +103,7 @@ contract PendleBtrflyScy is SCYBase {
     //////////////////////////////////////////////////////////////*/
 
     //solhint-disable-next-line no-empty-blocks
-    function redeemReward(address user, address receiver)
-        public
-        virtual
-        override
-        returns (uint256[] memory)
-    {}
+    function redeemReward(address user) public virtual override returns (uint256[] memory) {}
 
     //solhint-disable-next-line no-empty-blocks
     function updateGlobalReward() public virtual override {}

package/contracts/core/PendleSCYImpl/PendleYearnVaultSCY.sol

@@ -66,7 +66,7 @@ contract PendleYearnVaultScy is SCYBase {
     //////////////////////////////////////////////////////////////*/
 
     function scyIndexCurrent() public virtual override returns (uint256 res) {
-        res = FixedPoint.max(lastScyIndex, IYearnVault(yvToken).pricePerShare());
+        res = Math.max(lastScyIndex, IYearnVault(yvToken).pricePerShare());
         lastScyIndex = res;
         return res;
     }
@@ -93,12 +93,7 @@ contract PendleYearnVaultScy is SCYBase {
     //////////////////////////////////////////////////////////////*/
 
     //solhint-disable-next-line no-empty-blocks
-    function redeemReward(address user, address receiver)
-        public
-        virtual
-        override
-        returns (uint256[] memory)
-    {}
+    function redeemReward(address user) public virtual override returns (uint256[] memory) {}
 
     //solhint-disable-next-line no-empty-blocks
     function updateGlobalReward() public virtual override {}

package/contracts/core/PendleYieldContractFactory.sol

@@ -26,13 +26,13 @@ pragma solidity 0.8.9;
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import "../libraries/helpers/ExpiryUtilsLib.sol";
-import "./misc/BoringOwnable.sol";
+import "../periphery/PermissionsV2Upg.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 
 import "./PendleOwnershipToken.sol";
 import "./PendleYieldToken.sol";
 
-contract PendleYieldContractFactory is BoringOwnable, IPYieldContractFactory {
+contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory {
     using ExpiryUtils for string;
 
     string public constant OT_PREFIX = "OT";
@@ -45,12 +45,15 @@ contract PendleYieldContractFactory is BoringOwnable, IPYieldContractFactory {
     // SCY => expiry => address
     mapping(address => mapping(uint256 => address)) public getOT;
     mapping(address => mapping(uint256 => address)) public getYT;
+    mapping(address => bool) public isOT;
+    mapping(address => bool) public isYT;
 
     constructor(
         uint256 _expiryDivisor,
         uint256 _interestFeeRate,
-        address _treasury
-    ) BoringOwnable(msg.sender) {
+        address _treasury,
+        address _governanceManager
+    ) PermissionsV2Upg(_governanceManager) {
         expiryDivisor = _expiryDivisor;
         interestFeeRate = _interestFeeRate;
         treasury = _treasury;
@@ -93,17 +96,19 @@ contract PendleYieldContractFactory is BoringOwnable, IPYieldContractFactory {
 
         getOT[SCY][expiry] = OT;
         getYT[SCY][expiry] = YT;
+        isOT[OT] = true;
+        isYT[YT] = true;
     }
 
-    function setExpiryDivisor(uint256 newExpiryDivisor) external onlyOwner {
+    function setExpiryDivisor(uint256 newExpiryDivisor) external onlyGovernance {
         expiryDivisor = newExpiryDivisor;
     }
 
-    function setInterestFeeRate(uint256 newInterestFeeRate) external onlyOwner {
+    function setInterestFeeRate(uint256 newInterestFeeRate) external onlyGovernance {
         interestFeeRate = newInterestFeeRate;
     }
 
-    function setTreasury(address newTreasury) external onlyOwner {
+    function setTreasury(address newTreasury) external onlyGovernance {
         treasury = newTreasury;
     }
 }

package/contracts/core/PendleYieldToken.sol

@@ -5,15 +5,22 @@ import "./PendleBaseToken.sol";
 import "../SuperComposableYield/ISuperComposableYield.sol";
 import "../interfaces/IPYieldToken.sol";
 import "../interfaces/IPOwnershipToken.sol";
-import "../libraries/math/FixedPoint.sol";
+import "../libraries/math/Math.sol";
 import "../interfaces/IPYieldContractFactory.sol";
-import "@openzeppelin/contracts/utils/math/Math.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../SuperComposableYield/SCYUtils.sol";
 import "../SuperComposableYield/implementations/RewardManager.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 impliedScyBalance will not change over time, unless users redeem their interest or redeemYO.
+
+Due to this, it is required to update users' accruedReward STRICTLY BEFORE redeeming their interest.
+*/
 contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
-    using FixedPoint for uint256;
+    using Math for uint256;
     using SafeERC20 for IERC20;
 
     struct UserData {
@@ -77,39 +84,58 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
         _afterTransferOutSCY();
     }
 
+    function redeemDueInterestAndRewards(address user)
+        public
+        returns (uint256 interestOut, uint256[] memory rewardsOut)
+    {
+        // redeemDueRewards before redeemDueInterest
+        updateUserReward(user);
+        updateUserInterest(user);
+        rewardsOut = _doTransferOutRewardsForUser(user, user);
+        interestOut = _doTransferOutDueInterest(user);
+    }
+
     function redeemDueInterest(address user) public returns (uint256 interestOut) {
-        _updateDueInterest(user);
+        updateUserReward(user); /// strictly required, see above for explanation
+        updateUserInterest(user);
+        interestOut = _doTransferOutDueInterest(user);
+    }
 
-        uint256 interestPreFee = data[user].dueInterest;
-        data[user].dueInterest = 0;
+    function redeemDueRewards(address user) public returns (uint256[] memory rewardsOut) {
+        updateUserReward(user);
+        rewardsOut = _doTransferOutRewardsForUser(user, user);
+    }
 
-        uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
-        uint256 feeAmount = interestPreFee.mulDown(feeRate);
-        totalProtocolFee += feeAmount;
+    function updateGlobalReward() external {
+        address[] memory rewardTokens = getRewardTokens();
+        _updateGlobalReward(rewardTokens, IERC20(SCY).balanceOf(address(this)));
+    }
 
-        interestOut = interestPreFee - feeAmount;
-        IERC20(SCY).safeTransfer(user, interestOut);
-        _afterTransferOutSCY();
+    function updateUserReward(address user) public {
+        uint256 impliedScyBalance = getImpliedScyBalance(user);
+        uint256 totalScy = IERC20(SCY).balanceOf(address(this));
+        _updateUserReward(user, impliedScyBalance, totalScy);
     }
 
-    function redeemDueRewards(address user, address receiver)
-        public
-        returns (uint256[] memory rewardsOut)
-    {
-        if (user != msg.sender) require(receiver == user, "invalid receiver");
-        else require(receiver != address(0), "zero address");
+    function updateUserInterest(address user) public {
+        uint256 prevIndex = data[user].lastScyIndex;
 
-        _updateUserReward(user, balanceOf(user), totalSupply());
-        rewardsOut = _doTransferOutRewardsForUser(user, receiver);
-    }
+        uint256 currentIndex = getScyIndexBeforeExpiry();
 
-    function updateGlobalReward() public virtual {
-        address[] memory rewardTokens = getRewardTokens();
-        _updateGlobalReward(rewardTokens, totalSupply());
-    }
+        if (prevIndex == currentIndex) return;
+        if (prevIndex == 0) {
+            data[user].lastScyIndex = currentIndex;
+            return;
+        }
+
+        uint256 principal = balanceOf(user);
+
+        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(
+            prevIndex * currentIndex
+        );
 
-    function updateUserReward(address user) public virtual {
-        _updateUserReward(user, balanceOf(user), totalSupply());
+        data[user].dueInterest += interestFromYT;
+        data[user].lastScyIndex = currentIndex;
     }
 
     function _updateGlobalReward(address[] memory rewardTokens, uint256 totalSupply)
@@ -138,8 +164,21 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
         }
     }
 
+    function _doTransferOutDueInterest(address user) internal returns (uint256 interestOut) {
+        uint256 interestPreFee = data[user].dueInterest;
+        data[user].dueInterest = 0;
+
+        uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
+        uint256 feeAmount = interestPreFee.mulDown(feeRate);
+        totalProtocolFee += feeAmount;
+
+        interestOut = interestPreFee - feeAmount;
+        IERC20(SCY).safeTransfer(user, interestOut);
+        _afterTransferOutSCY();
+    }
+
     function _redeemExternalReward() internal virtual override {
-        ISuperComposableYield(SCY).redeemReward(address(this), address(this));
+        ISuperComposableYield(SCY).redeemReward(address(this));
     }
 
     function getRewardTokens()
@@ -158,8 +197,19 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
         lastScyIndexBeforeExpiry = res;
     }
 
+    /**
+     * In case the pool is expired and there is left some SCY not yet redeemed from the contract, the rewards should
+     * be claimed before withdrawing to treasury.
+     *
+     * And since the reward distribution (which based on users' dueInterest) stopped at the scyIndexBeforeExpiry, it is not
+     * necessary to updateDueInterest along with reward here.
+     */
     function withdrawFeeToTreasury() public {
-        address[] memory rewardTokens = ISuperComposableYield(SCY).getRewardTokens();
+        address[] memory rewardTokens = getRewardTokens();
+        if (isExpired()) {
+            _updateGlobalReward(rewardTokens, IERC20(SCY).balanceOf(address(this))); // as refered to the doc above
+        }
+
         uint256 length = rewardTokens.length;
         address treasury = IPYieldContractFactory(factory).treasury();
 
@@ -177,27 +227,6 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
         }
     }
 
-    function _updateDueInterest(address user) internal {
-        uint256 prevIndex = data[user].lastScyIndex;
-
-        uint256 currentIndex = getScyIndexBeforeExpiry();
-
-        if (prevIndex == currentIndex) return;
-        if (prevIndex == 0) {
-            data[user].lastScyIndex = currentIndex;
-            return;
-        }
-
-        uint256 principal = balanceOf(user);
-
-        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(
-            prevIndex * currentIndex
-        );
-
-        data[user].dueInterest += interestFromYT;
-        data[user].lastScyIndex = currentIndex;
-    }
-
     function _calcAmountToMint(uint256 amount) internal returns (uint256) {
         return SCYUtils.scyToAsset(getScyIndexBeforeExpiry(), amount);
     }
@@ -217,20 +246,29 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
         lastScyBalance = IERC20(SCY).balanceOf(address(this));
     }
 
+    function getImpliedScyBalance(address user) public view returns (uint256) {
+        uint256 scyIndex = data[user].lastScyIndex;
+        if (scyIndex == 0) return 0;
+        return SCYUtils.assetToScy(scyIndex, balanceOf(user)) + data[user].dueInterest;
+    }
+
     function _beforeTokenTransfer(
         address from,
         address to,
         uint256
     ) internal override {
         address[] memory rewardTokens = getRewardTokens();
-        _updateGlobalReward(rewardTokens, totalSupply());
+        _updateGlobalReward(rewardTokens, IERC20(SCY).balanceOf(address(this)));
+
+        // Before the change in YT balance, users' impliedScyBalance is kept unchanged from last time
+        // Therefore, both updating due interest before or after due reward work the same.
         if (from != address(0) && from != address(this)) {
-            _updateDueInterest(from);
-            _updateUserRewardSkipGlobal(rewardTokens, from, balanceOf(from));
+            updateUserInterest(from);
+            _updateUserRewardSkipGlobal(rewardTokens, from, getImpliedScyBalance(from));
         }
         if (to != address(0) && to != address(this)) {
-            _updateDueInterest(to);
-            _updateUserRewardSkipGlobal(rewardTokens, to, balanceOf(to));
+            updateUserInterest(to);
+            _updateUserRewardSkipGlobal(rewardTokens, to, getImpliedScyBalance(to));
         }
     }
 }