@pendle/core-v2 2.30.1 → 3.0.0-alpha-1

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/l2-contracts/ScalingDataL2Lib.sol/ScalingDataL2Lib.json

@@ -3,8 +3,8 @@
   "contractName": "ScalingDataL2Lib",
   "sourceName": "contracts/router/swap-aggregator/kyberswap/l2-contracts/ScalingDataL2Lib.sol",
   "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220d078e058a7a43cc8947546e8d2d532f7cba5955f861a02dea8e034195bbd960464736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220d078e058a7a43cc8947546e8d2d532f7cba5955f861a02dea8e034195bbd960464736f6c63430008170033",
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b47dc5f942c9cf301d157464112a21c8bae98a60966d6b934a18c3229a39502c64736f6c63430008170033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b47dc5f942c9cf301d157464112a21c8bae98a60966d6b934a18c3229a39502c64736f6c63430008170033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/swap-aggregator/oneinch/I1inchAggregationRouterV5.sol/I1inchAggregationRouterV5.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../../build-info/e2ea7c19c361d1241026e79eda282113.json"
+  "buildInfo": "../../../../../build-info/b8a77b6f1d4f10fbb0c6a4d526f977af.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/oneinch/OneInchAggregationRouterHelper.sol/OneInchAggregationRouterHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../../build-info/e2ea7c19c361d1241026e79eda282113.json"
+  "buildInfo": "../../../../../build-info/b8a77b6f1d4f10fbb0c6a4d526f977af.json"
 }

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -39,6 +39,7 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
 
     address public immutable pendle;
     IPMarketFactory public immutable marketFactory;
+    IPMarketFactory public immutable marketFactory2;
 
     mapping(address => MarketRewardData) public rewardData;
     mapping(uint128 => bool) public epochRewardReceived;
@@ -46,13 +47,20 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
     uint256[100] private __gap;
 
     modifier onlyPendleMarket() {
-        if (!marketFactory.isValidMarket(msg.sender)) revert Errors.GCNotPendleMarket(msg.sender);
-        _;
+        if (
+            marketFactory.isValidMarket(msg.sender) ||
+            (marketFactory2 != IPMarketFactory(address(0)) && marketFactory2.isValidMarket(msg.sender))
+        ) {
+            _;
+        } else {
+            revert Errors.GCNotPendleMarket(msg.sender);
+        }
     }
 
-    constructor(address _pendle, address _marketFactory) {
+    constructor(address _pendle, address _marketFactory, address _marketFactory2) {
         pendle = _pendle;
         marketFactory = IPMarketFactory(_marketFactory);
+        marketFactory2 = IPMarketFactory(_marketFactory2);
     }
 
     /**
@@ -91,7 +99,9 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
         epochRewardReceived[wTime] = true;
 
         for (uint256 i = 0; i < markets.length; ++i) {
-            if (!IPMarket(markets[i]).isExpired()) _addRewardsToMarket(markets[i], pendleAmounts[i].Uint128());
+            if (!IPMarket(markets[i]).isExpired()) {
+                _addRewardsToMarket(markets[i], pendleAmounts[i].Uint128());
+            }
         }
 
         emit ReceiveVotingResults(wTime, markets, pendleAmounts);

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerMainchainUpg.sol

@@ -12,23 +12,21 @@ contract PendleGaugeControllerMainchainUpg is PendleGaugeControllerBaseUpg, IPGa
         _;
     }
 
-    constructor(
-        address _votingController,
-        address _pendle,
-        address _marketFactory
-    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory) initializer {
+    constructor(address _votingController, address _pendle, address _marketFactory, address _marketFactory2)
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2)
+    {
         votingController = _votingController;
+        _disableInitializers();
     }
 
     function initialize() external initializer {
         __BoringOwnable_init();
     }
 
-    function updateVotingResults(
-        uint128 wTime,
-        address[] memory markets,
-        uint256[] memory pendleSpeeds
-    ) external onlyVotingController {
+    function updateVotingResults(uint128 wTime, address[] memory markets, uint256[] memory pendleSpeeds)
+        external
+        onlyVotingController
+    {
         _receiveVotingResults(wTime, markets, pendleSpeeds);
     }
 }

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -10,12 +10,14 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
     constructor(
         address _pendle,
         address _marketFactory,
+        address _marketFactory2,
         address _PendleMsgReceiveEndpointUpg
     )
-        PendleGaugeControllerBaseUpg(_pendle, _marketFactory)
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2)
         PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
-        initializer
-    {}
+    {
+        _disableInitializers();
+    }
 
     function initialize() external initializer {
         __BoringOwnable_init();

package/contracts/core/Market/v3/PendleMarketFactoryV3.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import "../../../interfaces/IPMarketV3.sol";
+import "../../../interfaces/IPYieldContractFactory.sol";
+import "../../../interfaces/IPMarketFactoryV3.sol";
+
+import "../../libraries/BaseSplitCodeFactory.sol";
+import "../../libraries/Errors.sol";
+import "../../libraries/BoringOwnableUpgradeable.sol";
+
+contract PendleMarketFactoryV3 is BoringOwnableUpgradeable, IPMarketFactoryV3 {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    address public immutable marketCreationCodeContractA;
+    uint256 public immutable marketCreationCodeSizeA;
+    address public immutable marketCreationCodeContractB;
+    uint256 public immutable marketCreationCodeSizeB;
+
+    address public immutable yieldContractFactory;
+    address public immutable vePendle;
+    address public immutable gaugeController;
+
+    uint256 public immutable maxLnFeeRateRoot;
+    uint8 public constant maxReserveFeePercent = 100;
+    int256 public constant minInitialAnchor = PMath.IONE;
+
+    address public treasury;
+    uint8 public reserveFeePercent;
+
+    // router -> market -> lnFeeRateRoot. lnFeeRateRoot == 0 means no override
+    mapping(address => mapping(address => uint80)) internal overriddenFee;
+
+    // PT -> scalarRoot -> initialAnchor
+    mapping(address => mapping(int256 => mapping(int256 => mapping(uint80 => address)))) internal markets;
+    EnumerableSet.AddressSet internal allMarkets;
+
+    constructor(
+        address _yieldContractFactory,
+        address _marketCreationCodeContractA,
+        uint256 _marketCreationCodeSizeA,
+        address _marketCreationCodeContractB,
+        uint256 _marketCreationCodeSizeB,
+        address _treasury,
+        uint8 _reserveFeePercent,
+        address _vePendle,
+        address _gaugeController
+    ) initializer {
+        yieldContractFactory = _yieldContractFactory;
+        maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * PMath.IONE) / 100))); // ln(1.05)
+
+        marketCreationCodeContractA = _marketCreationCodeContractA;
+        marketCreationCodeSizeA = _marketCreationCodeSizeA;
+        marketCreationCodeContractB = _marketCreationCodeContractB;
+        marketCreationCodeSizeB = _marketCreationCodeSizeB;
+
+        __BoringOwnable_init();
+        setTreasuryAndFeeReserve(_treasury, _reserveFeePercent);
+
+        vePendle = _vePendle;
+        gaugeController = _gaugeController;
+    }
+
+    /**
+     * @notice Create a market between PT and its corresponding SY with scalar & anchor config.
+     * Anyone is allowed to create a market on their own.
+     */
+    function createNewMarket(
+        address PT,
+        int256 scalarRoot,
+        int256 initialAnchor,
+        uint80 lnFeeRateRoot
+    ) external returns (address market) {
+        if (!IPYieldContractFactory(yieldContractFactory).isPT(PT)) revert Errors.MarketFactoryInvalidPt();
+        if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
+        if (lnFeeRateRoot > maxLnFeeRateRoot)
+            revert Errors.MarketFactoryLnFeeRateRootTooHigh(lnFeeRateRoot, maxLnFeeRateRoot);
+
+        if (markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] != address(0))
+            revert Errors.MarketFactoryMarketExists();
+
+        if (initialAnchor < minInitialAnchor)
+            revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
+
+        market = BaseSplitCodeFactory._create2(
+            0,
+            bytes32(block.chainid),
+            abi.encode(PT, scalarRoot, initialAnchor, lnFeeRateRoot, vePendle, gaugeController),
+            marketCreationCodeContractA,
+            marketCreationCodeSizeA,
+            marketCreationCodeContractB,
+            marketCreationCodeSizeB
+        );
+
+        markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] = market;
+
+        if (!allMarkets.add(market)) assert(false);
+
+        emit CreateNewMarket(market, PT, scalarRoot, initialAnchor, lnFeeRateRoot);
+    }
+
+    function getMarketConfig(
+        address market,
+        address router
+    ) external view returns (address _treasury, uint80 _overriddenFee, uint8 _reserveFeePercent) {
+        (_treasury, _reserveFeePercent) = (treasury, reserveFeePercent);
+        _overriddenFee = overriddenFee[router][market];
+    }
+
+    /// @dev for gas-efficient verification of market
+    function isValidMarket(address market) external view returns (bool) {
+        return allMarkets.contains(market);
+    }
+
+    function setTreasuryAndFeeReserve(address newTreasury, uint8 newReserveFeePercent) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
+        if (newReserveFeePercent > maxReserveFeePercent)
+            revert Errors.MarketFactoryReserveFeePercentTooHigh(newReserveFeePercent, maxReserveFeePercent);
+
+        treasury = newTreasury;
+        reserveFeePercent = newReserveFeePercent;
+
+        emit NewTreasuryAndFeeReserve(newTreasury, newReserveFeePercent);
+    }
+
+    function setOverriddenFee(address router, address market, uint80 newFee) public onlyOwner {
+        if (!allMarkets.contains(market)) revert Errors.MFNotPendleMarket(market);
+
+        uint80 marketFee = IPMarketV3(market).getNonOverrideLnFeeRateRoot();
+        if (newFee >= marketFee) revert Errors.MarketFactoryOverriddenFeeTooHigh(newFee, marketFee);
+
+        // NOTE: newFee = 0 allowed !!
+        overriddenFee[router][market] = newFee;
+        emit SetOverriddenFee(router, market, newFee);
+    }
+}

package/contracts/core/Market/v3/PendleMarketV3.sol

@@ -0,0 +1,360 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../interfaces/IPMarketV3.sol";
+import "../../../interfaces/IPMarketFactoryV3.sol";
+import "../../../interfaces/IPMarketSwapCallback.sol";
+
+import "../../erc20/PendleERC20Permit.sol";
+import "../PendleGauge.sol";
+import "../OracleLib.sol";
+
+/**
+Invariance to maintain:
+- Internal balances totalPt & totalSy not interfered by people transferring tokens in directly
+- 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 PendleMarketV3 is PendleERC20Permit, PendleGauge, IPMarketV3 {
+    using PMath for uint256;
+    using PMath for int256;
+    using MarketMathCore for MarketState;
+    using SafeERC20 for IERC20;
+    using PYIndexLib for IPYieldToken;
+    using OracleLib for OracleLib.Observation[65535];
+
+    struct MarketStorage {
+        int128 totalPt;
+        int128 totalSy;
+        // 1 SLOT = 256 bits
+        uint96 lastLnImpliedRate;
+        uint16 observationIndex;
+        uint16 observationCardinality;
+        uint16 observationCardinalityNext;
+        // 1 SLOT = 144 bits
+    }
+
+    string private constant NAME = "Pendle Market";
+    string private constant SYMBOL = "PENDLE-LPT";
+
+    IPPrincipalToken internal immutable PT;
+    IStandardizedYield internal immutable SY;
+    IPYieldToken internal immutable YT;
+
+    address public immutable factory;
+    uint256 public immutable expiry;
+
+    int256 internal immutable scalarRoot;
+    int256 internal immutable initialAnchor;
+    uint80 internal immutable lnFeeRateRoot;
+
+    MarketStorage public _storage;
+
+    OracleLib.Observation[65535] public observations;
+
+    modifier notExpired() {
+        if (isExpired()) revert Errors.MarketExpired();
+        _;
+    }
+
+    constructor(
+        address _PT,
+        int256 _scalarRoot,
+        int256 _initialAnchor,
+        uint80 _lnFeeRateRoot,
+        address _vePendle,
+        address _gaugeController
+    ) PendleERC20Permit(NAME, SYMBOL, 18) PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController) {
+        PT = IPPrincipalToken(_PT);
+        SY = IStandardizedYield(PT.SY());
+        YT = IPYieldToken(PT.YT());
+
+        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations.initialize(
+            uint32(block.timestamp)
+        );
+
+        if (_scalarRoot <= 0) revert Errors.MarketScalarRootBelowZero(_scalarRoot);
+
+        scalarRoot = _scalarRoot;
+        initialAnchor = _initialAnchor;
+        lnFeeRateRoot = _lnFeeRateRoot;
+        expiry = IPPrincipalToken(_PT).expiry();
+        factory = msg.sender;
+    }
+
+    /**
+     * @notice PendleMarket allows users to provide in PT & SY in exchange for LPs, which
+     * will grant LP holders more exchange fee over time
+     * @dev will mint as much LP as possible such that the corresponding SY and PT used do
+     * not exceed `netSyDesired` and `netPtDesired`, respectively
+     * @dev PT and SY should be transferred to this contract prior to calling
+     * @dev will revert if PT is expired
+     */
+    function mint(
+        address receiver,
+        uint256 netSyDesired,
+        uint256 netPtDesired
+    ) external nonReentrant notExpired returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
+        MarketState memory market = readState(msg.sender);
+        PYIndex index = YT.newIndex();
+
+        uint256 lpToReserve;
+
+        (lpToReserve, netLpOut, netSyUsed, netPtUsed) = market.addLiquidity(
+            netSyDesired,
+            netPtDesired,
+            block.timestamp
+        );
+
+        // initializing the market
+        if (lpToReserve != 0) {
+            market.setInitialLnImpliedRate(index, initialAnchor, block.timestamp);
+            _mint(address(1), lpToReserve);
+        }
+
+        _mint(receiver, netLpOut);
+
+        _writeState(market);
+
+        if (_selfBalance(SY) < market.totalSy.Uint())
+            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
+        if (_selfBalance(PT) < market.totalPt.Uint())
+            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
+
+        emit Mint(receiver, netLpOut, netSyUsed, netPtUsed);
+    }
+
+    /**
+     * @notice LP Holders can burn their LP to receive back SY & PT proportionally
+     * to their share of the market
+     */
+    function burn(
+        address receiverSy,
+        address receiverPt,
+        uint256 netLpToBurn
+    ) external nonReentrant returns (uint256 netSyOut, uint256 netPtOut) {
+        MarketState memory market = readState(msg.sender);
+
+        _burn(address(this), netLpToBurn);
+
+        (netSyOut, netPtOut) = market.removeLiquidity(netLpToBurn);
+
+        if (receiverSy != address(this)) IERC20(SY).safeTransfer(receiverSy, netSyOut);
+        if (receiverPt != address(this)) IERC20(PT).safeTransfer(receiverPt, netPtOut);
+
+        _writeState(market);
+
+        emit Burn(receiverSy, receiverPt, netLpToBurn, netSyOut, netPtOut);
+    }
+
+    /**
+     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
+     * aims to swap an exact amount of PT to SY.
+     * @dev steps working of this contract
+       - The outcome amount of SY will be precomputed by MarketMathLib
+       - Release the calculated amount of SY to receiver
+       - Callback to msg.sender if data.length > 0
+       - Ensure exactPtIn amount of PT has been transferred to this address
+     * @dev will revert if PT is expired
+     * @param data bytes data to be sent in the callback (if any)
+     */
+    function swapExactPtForSy(
+        address receiver,
+        uint256 exactPtIn,
+        bytes calldata data
+    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyFee) {
+        MarketState memory market = readState(msg.sender);
+
+        uint256 netSyToReserve;
+        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);
+
+        if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
+        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
+
+        _writeState(market);
+
+        if (data.length > 0) {
+            IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netSyOut.Int(), data);
+        }
+
+        if (_selfBalance(PT) < market.totalPt.Uint())
+            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
+
+        emit Swap(msg.sender, receiver, exactPtIn.neg(), netSyOut.Int(), netSyFee, netSyToReserve);
+    }
+
+    /**
+     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
+     * aims to swap SY for an exact amount of PT.
+     * @dev steps working of this function
+       - The exact outcome amount of PT will be transferred to receiver
+       - Callback to msg.sender if data.length > 0
+       - Ensure the calculated required amount of SY is transferred to this address
+     * @dev will revert if PT is expired
+     * @param data bytes data to be sent in the callback (if any)
+     */
+    function swapSyForExactPt(
+        address receiver,
+        uint256 exactPtOut,
+        bytes calldata data
+    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyFee) {
+        MarketState memory market = readState(msg.sender);
+
+        uint256 netSyToReserve;
+        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
+
+        if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
+        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
+
+        _writeState(market);
+
+        if (data.length > 0) {
+            IPMarketSwapCallback(msg.sender).swapCallback(exactPtOut.Int(), netSyIn.neg(), data);
+        }
+
+        // have received enough SY
+        if (_selfBalance(SY) < market.totalSy.Uint())
+            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
+
+        emit Swap(msg.sender, receiver, exactPtOut.Int(), netSyIn.neg(), netSyFee, netSyToReserve);
+    }
+
+    /// @notice forces balances to match reserves
+    function skim() external nonReentrant {
+        MarketState memory market = readState(msg.sender);
+        uint256 excessPt = _selfBalance(PT) - market.totalPt.Uint();
+        uint256 excessSy = _selfBalance(SY) - market.totalSy.Uint();
+        if (excessPt != 0) IERC20(PT).safeTransfer(market.treasury, excessPt);
+        if (excessSy != 0) IERC20(SY).safeTransfer(market.treasury, excessSy);
+    }
+
+    /**
+     * @notice redeems the user's reward
+     * @return amount of reward token redeemed, in the same order as `getRewardTokens()`
+     */
+    function redeemRewards(address user) external nonReentrant returns (uint256[] memory) {
+        return _redeemRewards(user);
+    }
+
+    /// @notice returns the list of reward tokens
+    function getRewardTokens() external view returns (address[] memory) {
+        return _getRewardTokens();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                ORACLE
+    //////////////////////////////////////////////////////////////*/
+
+    function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative) {
+        return
+            observations.observe(
+                uint32(block.timestamp),
+                secondsAgos,
+                _storage.lastLnImpliedRate,
+                _storage.observationIndex,
+                _storage.observationCardinality
+            );
+    }
+
+    function increaseObservationsCardinalityNext(uint16 cardinalityNext) external nonReentrant {
+        uint16 cardinalityNextOld = _storage.observationCardinalityNext;
+        uint16 cardinalityNextNew = observations.grow(cardinalityNextOld, cardinalityNext);
+        if (cardinalityNextOld != cardinalityNextNew) {
+            _storage.observationCardinalityNext = cardinalityNextNew;
+            emit IncreaseObservationCardinalityNext(cardinalityNextOld, cardinalityNextNew);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                READ/WRITE STATES
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice read the state of the market from storage into memory for gas-efficient manipulation
+     */
+    function readState(address router) public view returns (MarketState memory market) {
+        market.totalPt = _storage.totalPt;
+        market.totalSy = _storage.totalSy;
+        market.totalLp = totalSupply().Int();
+
+        uint80 overriddenFee;
+
+        (market.treasury, overriddenFee, market.reserveFeePercent) = IPMarketFactoryV3(factory).getMarketConfig(
+            address(this),
+            router
+        );
+
+        market.lnFeeRateRoot = overriddenFee == 0 ? lnFeeRateRoot : overriddenFee;
+        market.scalarRoot = scalarRoot;
+        market.expiry = expiry;
+
+        market.lastLnImpliedRate = _storage.lastLnImpliedRate;
+    }
+
+    /// @notice write back the state of the market from memory to storage
+    function _writeState(MarketState memory market) internal {
+        uint96 lastLnImpliedRate96 = market.lastLnImpliedRate.Uint96();
+        int128 totalPt128 = market.totalPt.Int128();
+        int128 totalSy128 = market.totalSy.Int128();
+
+        (uint16 observationIndex, uint16 observationCardinality) = observations.write(
+            _storage.observationIndex,
+            uint32(block.timestamp),
+            _storage.lastLnImpliedRate,
+            _storage.observationCardinality,
+            _storage.observationCardinalityNext
+        );
+
+        _storage.totalPt = totalPt128;
+        _storage.totalSy = totalSy128;
+        _storage.lastLnImpliedRate = lastLnImpliedRate96;
+        _storage.observationIndex = observationIndex;
+        _storage.observationCardinality = observationCardinality;
+
+        emit UpdateImpliedRate(block.timestamp, market.lastLnImpliedRate);
+    }
+
+    function getNonOverrideLnFeeRateRoot() external view returns (uint80) {
+        return lnFeeRateRoot;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            TRIVIAL FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function readTokens() external view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) {
+        _SY = SY;
+        _PT = PT;
+        _YT = YT;
+    }
+
+    function isExpired() public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(expiry);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    PENDLE GAUGE - RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _stakedBalance(address user) internal view override returns (uint256) {
+        return balanceOf(user);
+    }
+
+    function _totalStaked() internal view override returns (uint256) {
+        return totalSupply();
+    }
+
+    // solhint-disable-next-line ordering
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override(PendleERC20, PendleGauge) {
+        PendleGauge._beforeTokenTransfer(from, to, amount);
+    }
+
+    // solhint-disable-next-line ordering
+    function _afterTokenTransfer(address from, address to, uint256 amount) internal override(PendleERC20, PendleGauge) {
+        PendleGauge._afterTokenTransfer(from, to, amount);
+    }
+}

package/contracts/core/RewardManager/RewardManager.sol

@@ -36,18 +36,26 @@ abstract contract RewardManager is RewardManagerAbstract {
                 address token = tokens[i];
 
                 // the entire token balance of the contract must be the rewards of the contract
-                uint256 accrued = _selfBalance(tokens[i]) - rewardState[token].lastBalance;
-                uint256 index = rewardState[token].index;
+
+                RewardState memory _state = rewardState[token];
+                (uint256 lastBalance, uint256 index) = (_state.lastBalance, _state.index);
+
+                uint256 accrued = _selfBalance(tokens[i]) - lastBalance;
 
                 if (index == 0) index = INITIAL_REWARD_INDEX;
                 if (totalShares != 0) index += accrued.divDown(totalShares);
 
-                rewardState[token].index = index.Uint128();
-                rewardState[token].lastBalance += accrued.Uint128();
+                rewardState[token] = RewardState({
+                    index: index.Uint128(),
+                    lastBalance: (lastBalance + accrued).Uint128()
+                });
+                indexes[i] = index;
+            }
+        } else {
+            for (uint256 i = 0; i < tokens.length; i++) {
+                indexes[i] = rewardState[tokens[i]].index;
             }
         }
-
-        for (uint256 i = 0; i < tokens.length; i++) indexes[i] = rewardState[tokens[i]].index;
     }
 
     /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

@@ -26,7 +26,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
      */
     function claimRewards(
         address user
-    ) external virtual override nonReentrant returns (uint256[] memory rewardAmounts) {
+    ) external virtual override nonReentrant whenNotPaused returns (uint256[] memory rewardAmounts) {
         _updateAndDistributeRewards(user);
         rewardAmounts = _doTransferOutRewards(user, user);
 
@@ -54,9 +54,8 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         }
     }
 
-    function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory indexes) {
-        _updateRewardIndex();
-        return rewardIndexesStored();
+    function rewardIndexesCurrent() external override nonReentrant whenNotPaused returns (uint256[] memory indexes) {
+        (, indexes) = _updateRewardIndex();
     }
 
     function rewardIndexesStored() public view virtual override returns (uint256[] memory indexes) {