@pendle/core-v2 0.15.1-mainnet → 0.15.2-mainnet

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveUsdd3CrvPoolHelper.sol

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../../libraries/math/Math.sol";
+import "../../../../../interfaces/Curve/ICrvPool.sol";
+import "./Curve3CrvPoolHelper.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library CurveUsdd3CrvPoolHelper {
+    using Math for uint256;
+
+    uint256 internal constant N_COINS = 2;
+    uint256 internal constant A_PRECISION = 100;
+    uint256 internal constant PRECISION = 10**18;
+    uint256 internal constant rate_multiplier = 10**18;
+    uint256 internal constant FEE_DENOMINATOR = 10**10;
+
+    // LP == POOL
+    address internal constant POOL = 0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea;
+    address internal constant USDD = 0x0C10bF8FcB7Bf5412187A595ab97a3609160b5c6;
+    address internal constant LP_3CRV = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
+
+    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
+        balances[0] = ICrvPool(POOL).balances(0);
+        balances[1] = ICrvPool(POOL).balances(1);
+    }
+
+    function _getTokenAmounts(address token, uint256 amount)
+        internal
+        pure
+        returns (uint256[N_COINS] memory res)
+    {
+        res[token == USDD ? 0 : 1] = amount;
+    }
+
+    // ----------------- Forked from https://etherscan.io/address/0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea#code -----------------
+    function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
+        uint256 amp = ICrvPool(POOL).A_precise();
+
+        uint256[N_COINS] memory rates;
+
+        rates[0] = rate_multiplier;
+
+        if (token == USDD || token == LP_3CRV) {
+            rates[1] = Curve3CrvPoolHelper.get_virtual_price();
+        } else {
+            (amount, rates[1]) = Curve3CrvPoolHelper.preview3CrvDeposit(token, amount);
+            token = LP_3CRV;
+        }
+
+        uint256[N_COINS] memory amounts = _getTokenAmounts(token, amount);
+
+        uint256[N_COINS] memory old_balances = _getBalances();
+        uint256 D0 = get_D_mem(rates, old_balances, amp);
+        uint256[N_COINS] memory new_balances = arrayClone(old_balances);
+
+        uint256 total_supply = IERC20(POOL).totalSupply();
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            new_balances[i] += amounts[i];
+        }
+
+        // Invariant after change
+        uint256 D1 = get_D_mem(rates, new_balances, amp);
+        assert(D1 > D0);
+
+        // We need to recalculate the invariant accounting for fees
+        // to calculate fair user's share
+        uint256[N_COINS] memory fees;
+        uint256 mint_amount = 0;
+
+        uint256 base_fee = (ICrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
+            uint256 difference = 0;
+            uint256 new_balance = new_balances[i];
+            if (ideal_balance > new_balance) {
+                difference = ideal_balance - new_balance;
+            } else {
+                difference = new_balance - ideal_balance;
+            }
+            fees[i] = (base_fee * difference) / FEE_DENOMINATOR;
+            new_balances[i] -= fees[i];
+        }
+        uint256 D2 = get_D_mem(rates, new_balances, amp);
+        mint_amount = (total_supply * (D2 - D0)) / D0;
+        return mint_amount;
+    }
+
+    function get_D_mem(
+        uint256[N_COINS] memory _rates,
+        uint256[N_COINS] memory _balances,
+        uint256 _amp
+    ) internal pure returns (uint256) {
+        uint256[N_COINS] memory xp = _xp_mem(_rates, _balances);
+        return get_D(xp, _amp);
+    }
+
+    function _xp_mem(uint256[N_COINS] memory _rates, uint256[N_COINS] memory balances)
+        internal
+        pure
+        returns (uint256[N_COINS] memory)
+    {
+        uint256[N_COINS] memory result;
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            result[i] = balances[i] * _rates[i] / PRECISION;
+        }
+        return result;
+    }
+
+    function get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
+        uint256 S = 0;
+        uint256 Dprev = 0;
+        for (uint256 k = 0; k < N_COINS; ++k) {
+            S += _xp[k];
+        }
+        if (S == 0) return 0;
+
+        uint256 D = S;
+        uint256 Ann = _amp * N_COINS;
+        for (uint256 _i = 0; _i < 255; ++_i) {
+            uint256 D_P = D;
+            for (uint256 k = 0; k < N_COINS; ++k) {
+                D_P = (D_P * D) / (_xp[k] * N_COINS);
+            }
+            Dprev = D;
+            D =
+                (((Ann * S) / A_PRECISION + D_P * N_COINS) * D) /
+                (((Ann - A_PRECISION) * D) / A_PRECISION + (N_COINS + 1) * D_P);
+
+            if (D > Dprev) {
+                if (D - Dprev <= 1) {
+                    return D;
+                }
+            } else {
+                if (Dprev - D <= 1) {
+                    return D;
+                }
+            }
+        }
+        assert(false);
+    }
+
+    function arrayClone(uint256[N_COINS] memory a)
+        internal
+        pure
+        returns (uint256[N_COINS] memory res)
+    {
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            res[i] = a[i];
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Convex/{ConvexCurveLP → base}/PendleConvexLPSY.sol

@@ -143,12 +143,10 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         override
         returns (uint256 amountTokenOut)
     {
-        uint256 amountLpTokenToReceive = (amountSharesToRedeem * exchangeRate()) / 1e18;
-
         if (tokenOut == crvLp) {
-            amountTokenOut = amountLpTokenToReceive;
+            amountTokenOut = amountSharesToRedeem;
         } else {
-            amountTokenOut = _previewRedeemFromCurve(tokenOut, amountLpTokenToReceive);
+            amountTokenOut = _previewRedeemFromCurve(tokenOut, amountSharesToRedeem);
         }
     }
 

package/contracts/core/StandardizedYield/implementations/PendleLooksStakingSY.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/ILooksFeeSharing.sol";
+import "../../../interfaces/ILooksStaking.sol";
+
+contract PendleLooksStakingSY is SYBase {
+    using Math for uint256;
+
+    address public immutable looks;
+    address public immutable stakingContract;
+    address public immutable feeSharingContract;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _looks,
+        address _stakingContract,
+        address _feeSharingContract
+    ) SYBase(_name, _symbol, _looks) {
+        looks = _looks;
+        stakingContract = _stakingContract;
+        feeSharingContract = _feeSharingContract;
+
+        _safeApproveInf(_looks, _stakingContract);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        uint256 previousShare = ILooksStaking(stakingContract).userInfo(address(this));
+        ILooksStaking(stakingContract).deposit(amountDeposited);
+        amountSharesOut = ILooksStaking(stakingContract).userInfo(address(this)) - previousShare;
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        uint256 previousBalance = _selfBalance(looks);
+        ILooksStaking(stakingContract).withdraw(amountSharesToRedeem);
+        amountTokenOut = _selfBalance(looks) - previousBalance;
+        _transferOut(looks, receiver, amountTokenOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        uint256 totalShares = ILooksStaking(stakingContract).totalShares();
+        uint256 totalLooks = ILooksFeeSharing(feeSharingContract).calculateSharesValueInLOOKS(
+            stakingContract
+        );
+        return totalLooks.divDown(totalShares);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev LooksRare also uses 1e18 precision, so it is accurate to
+     * calculate preview results using our built-in exchangeRate function
+     */
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        amountSharesOut = amountTokenToDeposit.divDown(exchangeRate());
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = amountSharesToRedeem.mulDown(exchangeRate());
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = looks;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = looks;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == looks;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == looks;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, looks, IERC20Metadata(looks).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/PendleWstEthSY.sol

@@ -50,9 +50,10 @@ contract PendleWstEthSY is SYBase {
             } else {
                 if (tokenIn == wETH) IWETH(wETH).withdraw(amountDeposited);
 
-                uint256 preBalanceStEth = _selfBalance(stETH);
-                IStETH(stETH).submit{ value: amountDeposited }(address(0));
-                amountStETH = _selfBalance(stETH) - preBalanceStEth;
+                uint256 amountStEthSharesOut = IStETH(stETH).submit{ value: amountDeposited }(
+                    address(0)
+                );
+                amountStETH = IStETH(stETH).getPooledEthByShares(amountStEthSharesOut);
             }
             amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
         }
@@ -101,13 +102,21 @@ contract PendleWstEthSY is SYBase {
     {
         if (tokenIn == wstETH) amountSharesOut = amountTokenToDeposit;
         else {
-            uint256 amountStETH;
-            if (tokenIn == stETH) {
-                amountStETH = amountTokenToDeposit;
+            if (tokenIn != stETH) {
+                uint256 totalShares = IStETH(stETH).getTotalShares();
+                uint256 totalPooledEth = IStETH(stETH).getTotalPooledEther();
+                uint256 amountStEthSharesOut = IStETH(stETH).getSharesByPooledEth(
+                    amountTokenToDeposit
+                );
+
+                totalShares += amountStEthSharesOut;
+                totalPooledEth += amountTokenToDeposit;
+
+                uint256 stEthBalance = (amountStEthSharesOut * totalPooledEth) / totalShares;
+                amountSharesOut = (stEthBalance * totalShares) / totalPooledEth;
             } else {
-                amountStETH = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
+                amountSharesOut = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
             }
-            amountSharesOut = IStETH(stETH).getSharesByPooledEth(amountStETH);
         }
     }
 

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -9,7 +9,7 @@ import "../libraries/Errors.sol";
 
 import "../erc20/PendleERC20Permit.sol";
 
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
     address public immutable SY;
@@ -22,7 +22,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         _;
     }
 
-    modifier onlYieldFactory() {
+    modifier onlyYieldFactory() {
         if (msg.sender != factory) revert Errors.OnlyYCFactory();
         _;
     }
@@ -39,7 +39,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         factory = msg.sender;
     }
 
-    function initialize(address _YT) external initializer onlYieldFactory {
+    function initialize(address _YT) external initializer onlyYieldFactory {
         YT = _YT;
     }
 

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -33,6 +33,7 @@ import "../libraries/BaseSplitCodeFactory.sol";
 import "../libraries/MiniHelpers.sol";
 import "../libraries/Errors.sol";
 import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/StringLib.sol";
 
 import "./PendlePrincipalToken.sol";
 import "./PendleYieldToken.sol";
@@ -40,9 +41,12 @@ import "./PendleYieldToken.sol";
 /// @dev If this contract is ever made upgradeable, please pay attention to the numContractDeployed variable
 contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContractFactory {
     using ExpiryUtils for string;
+    using StringLib for string;
+    using StringLib for StringLib.slice;
 
     string private constant PT_PREFIX = "PT";
     string private constant YT_PREFIX = "YT";
+    string private constant SY_PREF = "SY-";
 
     address public immutable ytCreationCodeContractA;
     uint256 public immutable ytCreationCodeSizeA;
@@ -58,11 +62,15 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     uint96 public expiryDivisor;
 
     // SY => expiry => address
+    // returns address(0) if not created
     mapping(address => mapping(uint256 => address)) public getPT;
     mapping(address => mapping(uint256 => address)) public getYT;
     mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
+    uint256 public constant maxInterestFeeRate = 2e17; // 20%
+    uint256 public constant maxRewardFeeRate = 2e17; // 20%
+
     constructor(
         address _ytCreationCodeContractA,
         uint256 _ytCreationCodeSizeA,
@@ -92,10 +100,10 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
      * @notice Create a pair of (PT, YT) from any SY 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 SY, uint32 expiry)
-        external
-        returns (address PT, address YT)
-    {
+    function createYieldContract(
+        address SY,
+        uint32 expiry
+    ) external returns (address PT, address YT) {
         if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
             revert Errors.YCFactoryInvalidExpiry();
 
@@ -105,6 +113,9 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
 
         (, , uint8 assetDecimals) = _SY.assetInfo();
 
+        string memory syCoreName = _stripSYPrefix(_SY.name());
+        string memory syCoreSymbol = _stripSYPrefix(_SY.symbol());
+
         PT = Create2.deploy(
             0,
             bytes32(block.chainid),
@@ -112,8 +123,8 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
                 type(PendlePrincipalToken).creationCode,
                 abi.encode(
                     SY,
-                    PT_PREFIX.concat(_SY.name(), expiry, " "),
-                    PT_PREFIX.concat(_SY.symbol(), expiry, "-"),
+                    PT_PREFIX.concat(syCoreName, expiry, " "),
+                    PT_PREFIX.concat(syCoreSymbol, expiry, "-"),
                     assetDecimals,
                     expiry
                 )
@@ -126,8 +137,8 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
             abi.encode(
                 SY,
                 PT,
-                YT_PREFIX.concat(_SY.name(), expiry, " "),
-                YT_PREFIX.concat(_SY.symbol(), expiry, "-"),
+                YT_PREFIX.concat(syCoreName, expiry, " "),
+                YT_PREFIX.concat(syCoreSymbol, expiry, "-"),
                 assetDecimals,
                 expiry
             ),
@@ -148,22 +159,38 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     }
 
     function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
+        if (newExpiryDivisor == 0) revert Errors.YCFactoryZeroExpiryDivisor();
+
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
     function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
+        if (newInterestFeeRate > maxInterestFeeRate)
+            revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
+
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
-    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyOwner {
-        rewardFeeRate = newInterestFeeRate;
-        emit SetInterestFeeRate(newInterestFeeRate);
+    function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
+        if (newRewardFeeRate > maxRewardFeeRate)
+            revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
+
+        rewardFeeRate = newRewardFeeRate;
+        emit SetRewardFeeRate(newRewardFeeRate);
     }
 
     function setTreasury(address newTreasury) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.YCFactoryZeroTreasury();
+
         treasury = newTreasury;
         emit SetTreasury(newTreasury);
     }
+
+    function _stripSYPrefix(string memory _str) internal pure returns (string memory) {
+        StringLib.slice memory str = _str.toSlice();
+        StringLib.slice memory delim = SY_PREF.toSlice();
+        return str.beyond(delim).toString();
+    }
 }

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -45,7 +45,9 @@ contract PendleYieldToken is
     address public immutable factory;
     uint256 public immutable expiry;
 
-    uint128 public syReserve;
+    uint256 public syReserve;
+
+    uint128 public pyIndexLastUpdatedBlock;
     uint128 internal _pyIndexStored;
 
     PostExpiryData public postExpiry;
@@ -61,6 +63,9 @@ contract PendleYieldToken is
         _;
     }
 
+    /**
+     * for all txs within the same block. Otherwise, the PY index is recalculated for every tx.
+     */
     constructor(
         address _SY,
         address _PT,
@@ -75,7 +80,10 @@ contract PendleYieldToken is
         factory = msg.sender;
     }
 
-    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
+    /** 
+     * @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
+     * @dev SY should be transferred directly into this contract prior to calling this function
+     */
     function mintPY(address receiverPT, address receiverYT)
         external
         nonReentrant
@@ -97,7 +105,7 @@ contract PendleYieldToken is
         amountPYOut = amountPYOuts[0];
     }
 
-    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
+    /// @notice Tokenize SY into PT + YT for multiple receivers. See `mintPY()` for more details
     function mintPYMulti(
         address[] calldata receiverPTs,
         address[] calldata receiverYTs,
@@ -116,7 +124,10 @@ contract PendleYieldToken is
         amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
     }
 
-    /// @dev this function converts PY tokens into sy, but interests & rewards are not redeemed at the same time
+    /**
+     * @notice Converts PY tokens into SY, but interests & rewards are not redeemed at the same time
+     * @dev PT/YT tokens should be transferred into this contract prior to redeeming
+     */
     function redeemPY(address receiver)
         external
         nonReentrant
@@ -133,9 +144,10 @@ contract PendleYieldToken is
         amountSyOut = amountSyOuts[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
+    /** 
+     * @notice Converts PY tokens into SY for multiple receivers. See (`redeemPY`) for more details
+     * @dev Reverts if unable to redeem the total amount in `amountPYToRedeems`
+     */
     function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
         nonReentrant
@@ -148,12 +160,15 @@ contract PendleYieldToken is
     }
 
     /**
-    * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
-    distribution should be based on the amount of SYs 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.
-    */
+     * @notice Redeems interests and rewards for `user`
+     * @param redeemInterest will only transfer out interest for user if true
+     * @param redeemRewards will only transfer out rewards for user if true
+     * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
+     * distribution should be based on the amount of SYs 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,
@@ -182,6 +197,7 @@ contract PendleYieldToken is
         }
     }
 
+    /// @dev reverts if called before expiry
     function redeemInterestAndRewardsPostExpiryForTreasury()
         external
         nonReentrant
@@ -208,21 +224,36 @@ contract PendleYieldToken is
         _transferOut(SY, treasury, interestOut);
     }
 
+    /// @notice updates and returns the reward indexes
     function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
         return IStandardizedYield(SY).rewardIndexesCurrent();
     }
 
-    /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
+    /// @dev maximizes the current rate with the previous rate to guarantee non-decreasing rate
     function pyIndexCurrent() public nonReentrant returns (uint256 currentIndex) {
         currentIndex = _pyIndexCurrent();
     }
+    
+    /// @notice returns the last-updated PY index
+    function pyIndexStored() public view returns (uint256) {
+        return _pyIndexStored;
+    }
 
+    /// @dev has no effect if called pre-expiry
     function setPostExpiryData() external nonReentrant {
         if (isExpired()) {
             _setPostExpiryData();
         }
     }
 
+    /**
+     * @notice returns the current data post-expiry, if exists
+     * @dev reverts if post-expiry data not set (see `setPostExpiryData()`)
+     * @return firstPYIndex the earliest PY index post-expiry
+     * @return totalSyInterestForTreasury current amount of SY interests post-expiry for treasury
+     * @return firstRewardIndexes the earliest reward indices post-expiry, for each reward token
+     * @return userRewardOwed amount of unclaimed user rewards, for each reward token
+     */
     function getPostExpiryData()
         external
         view
@@ -273,10 +304,6 @@ contract PendleYieldToken is
         }
     }
 
-    function pyIndexStored() public view returns (uint256) {
-        return _pyIndexStored;
-    }
-
     function isExpired() public view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
@@ -336,7 +363,7 @@ contract PendleYieldToken is
     }
 
     function _updateSyReserve() internal virtual {
-        syReserve = _selfBalance(SY).Uint128();
+        syReserve = _selfBalance(SY);
     }
 
     function _getFloatingSyAmount() internal view returns (uint256 amount) {
@@ -369,8 +396,14 @@ contract PendleYieldToken is
     }
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        currentIndex = Math.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored);
-        _pyIndexStored = currentIndex.Uint128();
+        uint128 index128 = Math
+            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
+            .Uint128();
+
+        currentIndex = index128;
+        _pyIndexStored = index128;
+        pyIndexLastUpdatedBlock = uint128(block.number);
+
         emit NewInterestIndex(currentIndex);
     }