@pendle/core-v2 2.8.3-mainnet → 2.9.0-mainnet

package/contracts/oracles/PendlePtOracleLib.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../core/libraries/math/Math.sol";
+
+library PendlePtOracleLib {
+    using Math for uint256;
+
+    /**
+     * This function returns the twap rate PT/Asset on market
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getPtToAssetRate(IPMarket market, uint32 duration)
+        internal
+        view
+        returns (uint256 ptToAssetRate)
+    {
+        uint256 expiry = market.expiry();
+        if (expiry <= block.timestamp) {
+            return _getPtToAssetRatePostExpiry(market);
+        }
+        uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
+        uint256 timeToExpiry = expiry - block.timestamp;
+        uint256 assetToPtRate = uint256(
+            MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry)
+        );
+
+        ptToAssetRate = Math.ONE.divDown(assetToPtRate);
+    }
+
+    function _getMarketLnImpliedRate(IPMarket market, uint32 duration)
+        private
+        view
+        returns (uint256)
+    {
+        uint32[] memory durations = new uint32[](2);
+        durations[0] = duration;
+
+        uint216[] memory lnImpliedRateCumulative = market.observe(durations);
+        return (lnImpliedRateCumulative[1] - lnImpliedRateCumulative[0]) / duration;
+    }
+
+    function _getPtToAssetRatePostExpiry(IPMarket market) private view returns (uint256) {
+        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
+
+        uint256 syIndex = SY.exchangeRate();
+        uint256 pyIndexCurrent;
+
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            pyIndexCurrent = YT.pyIndexStored();
+        } else {
+            pyIndexCurrent = Math.max(syIndex, YT.pyIndexStored());
+        }
+
+        return syIndex.divDown(pyIndexCurrent);
+    }
+}

package/contracts/oracles/samples/PendlePtGlpOracle.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../PendlePtOracleLib.sol";
+import "../../interfaces/IPPtOracle.sol";
+import "../../interfaces/GMX/IGlpManager.sol";
+import "../../core/libraries/math/Math.sol";
+
+/**
+ * @notice The returned price from this contract is multiply with the USD price of GLP read from
+ * GLPManager contract
+ *
+ * @dev This contract uses the PendlePtOracleLibrary to get the price instead of calling PendlePtOracle contract
+ * to save 1 external call gas consumption
+ */
+contract PendlePtGlpOracle {
+    using PendlePtOracleLib for IPMarket;
+
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable glpManager;
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+
+    constructor(
+        address _ptOracle,
+        uint32 _twapDuration,
+        address _market,
+        address _glpManager
+    ) {
+        twapDuration = _twapDuration;
+        market = _market;
+        glpManager = _glpManager;
+
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
+            _ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
+        }
+    }
+
+    function getPtPrice() external view virtual returns (uint256) {
+        // using library directly to save 1 external call (gas optimization)
+        uint256 ptRate = IPMarket(market).getPtToAssetRate(twapDuration);
+        uint256 assetPrice = IGlpManager(glpManager).getPrice(true);
+        return (assetPrice * ptRate) / Math.ONE;
+    }
+
+    function decimals() external pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/contracts/oracles/samples/PendlePtUsdChainlinkOracle.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPPtOracle.sol";
+import "../../core/libraries/math/Math.sol";
+import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+/**
+ * @notice The returned price from this contract is multiply with the default USD price of asset
+ * read from Chainlink Oracles
+ *
+ * @dev The ptRate is fetched from PendlePtOracle contract
+ */
+contract PendlePtUsdChainlinkOracle {
+    address public immutable ptOracle;
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable feed;
+    uint8 public immutable feedDecimals;
+
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+
+    constructor(
+        address _ptOracle,
+        uint32 _twapDuration,
+        address _market,
+        address _feed
+    ) {
+        ptOracle = _ptOracle;
+        twapDuration = _twapDuration;
+        market = _market;
+        feed = _feed;
+        feedDecimals = IChainlinkAggregator(feed).decimals();
+
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
+            _ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
+        }
+    }
+
+    function getPtPrice() external view virtual returns (uint256) {
+        uint256 ptRate = IPPtOracle(ptOracle).getPtToAssetRate(market, twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ptRate) / Math.ONE;
+    }
+
+    function _getUnderlyingAssetPrice() internal view virtual returns (uint256) {
+        uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
+        return
+            feedDecimals < 18
+                ? rawPrice * 10**(18 - feedDecimals)
+                : rawPrice / 10**(feedDecimals - 18);
+    }
+
+    function decimals() external pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/deployments/1-core.json

@@ -23,10 +23,11 @@
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
     "pendleSwap": "0x38812C3AC3563Bf200482ac9D096952D7cB55f9b",
+    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
+    "ptOracle": "0x414d3C8A26157085f286abE3BC6E1bb010733602",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
-    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
-    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335"
+    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2"
 }

package/deployments/1-markets/BALANCER-LP-AURA-ANKRETH-WETH-SEP-26-2024.json

@@ -1,11 +1,11 @@
 {
     "name": "SY ankrETH-WETH_BalancerLP Aura",
-    "SY": "0x2C662f901546a503C90d8dE0DB8BfF1d32FF4A39",
-    "YT": "0x210e6E4addd3fE31240a02DaD104B83634eA0426",
-    "PT": "0x5E9Aaf3b0b09C78C8651968dd1A4d0Ed0D0B55e9",
-    "market": "0xe84b47e626c8dcc021a585a059819cC54946f95A",
+    "SY": "0x7f531a70A240Fba0e40169E56EedE1C6B7Ef8463",
+    "YT": "0x5A0f44FE239856091C52a4b2114aba55773b9c8d",
+    "PT": "0xD961c25aDb22171B142f7e9E14dF01962D4decDf",
+    "market": "0xabC8ae339e3F560BF700A3f6eE85Ee719979762b",
     "expiry": 1727308800,
-    "bulkSeller": "0x2CFf4F4578CFE2220E34C75169CE7C49F3cc56fa",
+    "bulkSeller": "0x7d54A138835C66cb930aaF66C6007B3FC5bc731c",
     "scalarRoot": "24629050000000000000",
     "initAnchor": "1172739000000000000"
 }

package/deployments/1-markets/BALANCER-LP-AURA-RETH-WETH-DEC-26-2024.json

@@ -1,11 +1,11 @@
 {
     "name": "SY rETH-WETH_BalancerLP Aura",
-    "SY": "0x9Bdb1dfD15D9051D127c3cD6882e194cA1c89e56",
-    "YT": "0xE1578305ACC1BA40a331fd8cC9c8aEA1C2F21c9c",
-    "PT": "0x73AA4ce1d62E30AA0207eaF25De6aC3bEba9E7fd",
-    "market": "0x7E9Ad57D949b7aE03588a5bCBa85016F76B462f7",
+    "SY": "0xc0dd85720E3Bc7959890127b5d3Af2D29f6C74f4",
+    "YT": "0x1524b28167a54C5Daef3d1A511A31436ACC91ed0",
+    "PT": "0xa5D0d71cB2601d7082E1c39cF1B6f131Bf866a33",
+    "market": "0x2EC8C498ec997aD963969a2c93Bf7150a1F5b213",
     "expiry": 1735171200,
-    "bulkSeller": "0xFa6c7Eb155ad7A9f9Ad5f6C5178eb7e929BF8C09",
+    "bulkSeller": "0x3d9E694db2F50c31cA9bBb61c8C0046CeDC569cC",
     "scalarRoot": "52750270000000000000",
     "initAnchor": "1104792000000000000"
 }

package/deployments/42161-core.json

@@ -21,6 +21,7 @@
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
     "pendleSwap": "0xF0bF560F01d4196773a5c58A09d6D34b6bba4503",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
+    "ptOracle": "0x428f2f93afAc3F96B0DE59854038c585e06165C8",
     "receiverEndpoint": "0xC9215ae9EC67385F38C755D862C8eE3702B5793A",
     "vePendle": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
     "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00"

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.8.3-mainnet",
+  "version": "2.9.0-mainnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -44,6 +44,7 @@
   },
   "packageManager": "yarn@3.3.1",
   "dependencies": {
+    "@chainlink/contracts": "^0.6.1",
     "@openzeppelin/contracts": "4.7.3",
     "@openzeppelin/contracts-upgradeable": "4.7.3"
   }

package/typechain-types/IGlpManager.ts

@@ -26,6 +26,7 @@ export interface IGlpManagerInterface extends utils.Interface {
   contractName: "IGlpManager";
   functions: {
     "getAumInUsdg(bool)": FunctionFragment;
+    "getPrice(bool)": FunctionFragment;
     "gov()": FunctionFragment;
     "setCooldownDuration(uint256)": FunctionFragment;
     "vault()": FunctionFragment;
@@ -35,6 +36,7 @@ export interface IGlpManagerInterface extends utils.Interface {
     functionFragment: "getAumInUsdg",
     values: [boolean]
   ): string;
+  encodeFunctionData(functionFragment: "getPrice", values: [boolean]): string;
   encodeFunctionData(functionFragment: "gov", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "setCooldownDuration",
@@ -46,6 +48,7 @@ export interface IGlpManagerInterface extends utils.Interface {
     functionFragment: "getAumInUsdg",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "getPrice", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "gov", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "setCooldownDuration",
@@ -89,6 +92,11 @@ export interface IGlpManager extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
+    getPrice(
+      _maximise: boolean,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
     gov(overrides?: CallOverrides): Promise<[string]>;
 
     setCooldownDuration(
@@ -104,6 +112,8 @@ export interface IGlpManager extends BaseContract {
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  getPrice(_maximise: boolean, overrides?: CallOverrides): Promise<BigNumber>;
+
   gov(overrides?: CallOverrides): Promise<string>;
 
   setCooldownDuration(
@@ -119,6 +129,8 @@ export interface IGlpManager extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    getPrice(_maximise: boolean, overrides?: CallOverrides): Promise<BigNumber>;
+
     gov(overrides?: CallOverrides): Promise<string>;
 
     setCooldownDuration(
@@ -137,6 +149,8 @@ export interface IGlpManager extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    getPrice(_maximise: boolean, overrides?: CallOverrides): Promise<BigNumber>;
+
     gov(overrides?: CallOverrides): Promise<BigNumber>;
 
     setCooldownDuration(
@@ -153,6 +167,11 @@ export interface IGlpManager extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    getPrice(
+      _maximise: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     gov(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     setCooldownDuration(

package/typechain-types/IPMarket.ts

@@ -59,6 +59,7 @@ export type MarketStateStructOutput = [
 export interface IPMarketInterface extends utils.Interface {
   contractName: "IPMarket";
   functions: {
+    "_storage()": FunctionFragment;
     "activeBalance(address)": FunctionFragment;
     "allowance(address,address)": FunctionFragment;
     "approve(address,uint256)": FunctionFragment;
@@ -71,6 +72,7 @@ export interface IPMarketInterface extends utils.Interface {
     "isExpired()": FunctionFragment;
     "mint(address,uint256,uint256)": FunctionFragment;
     "name()": FunctionFragment;
+    "observations(uint256)": FunctionFragment;
     "observe(uint32[])": FunctionFragment;
     "readState(address)": FunctionFragment;
     "readTokens()": FunctionFragment;
@@ -84,6 +86,7 @@ export interface IPMarketInterface extends utils.Interface {
     "transferFrom(address,address,uint256)": FunctionFragment;
   };
 
+  encodeFunctionData(functionFragment: "_storage", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "activeBalance",
     values: [string]
@@ -117,6 +120,10 @@ export interface IPMarketInterface extends utils.Interface {
     values: [string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(functionFragment: "name", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "observations",
+    values: [BigNumberish]
+  ): string;
   encodeFunctionData(
     functionFragment: "observe",
     values: [BigNumberish[]]
@@ -156,6 +163,7 @@ export interface IPMarketInterface extends utils.Interface {
     values: [string, string, BigNumberish]
   ): string;
 
+  decodeFunctionResult(functionFragment: "_storage", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "activeBalance",
     data: BytesLike
@@ -177,6 +185,10 @@ export interface IPMarketInterface extends utils.Interface {
   decodeFunctionResult(functionFragment: "isExpired", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "observations",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "observe", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "readState", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "readTokens", data: BytesLike): Result;
@@ -328,6 +340,19 @@ export interface IPMarket extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
+    _storage(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, number, number, number] & {
+        totalPt: BigNumber;
+        totalSy: BigNumber;
+        lastLnImpliedRate: BigNumber;
+        observationIndex: number;
+        observationCardinality: number;
+        observationCardinalityNext: number;
+      }
+    >;
+
     activeBalance(
       user: string,
       overrides?: CallOverrides
@@ -376,6 +401,17 @@ export interface IPMarket extends BaseContract {
 
     name(overrides?: CallOverrides): Promise<[string]>;
 
+    observations(
+      index: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [number, BigNumber, boolean] & {
+        blockTimestamp: number;
+        lnImpliedRateCumulative: BigNumber;
+        initialized: boolean;
+      }
+    >;
+
     observe(
       secondsAgos: BigNumberish[],
       overrides?: CallOverrides
@@ -431,6 +467,19 @@ export interface IPMarket extends BaseContract {
     ): Promise<ContractTransaction>;
   };
 
+  _storage(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, number, number, number] & {
+      totalPt: BigNumber;
+      totalSy: BigNumber;
+      lastLnImpliedRate: BigNumber;
+      observationIndex: number;
+      observationCardinality: number;
+      observationCardinalityNext: number;
+    }
+  >;
+
   activeBalance(user: string, overrides?: CallOverrides): Promise<BigNumber>;
 
   allowance(
@@ -476,6 +525,17 @@ export interface IPMarket extends BaseContract {
 
   name(overrides?: CallOverrides): Promise<string>;
 
+  observations(
+    index: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [number, BigNumber, boolean] & {
+      blockTimestamp: number;
+      lnImpliedRateCumulative: BigNumber;
+      initialized: boolean;
+    }
+  >;
+
   observe(
     secondsAgos: BigNumberish[],
     overrides?: CallOverrides
@@ -531,6 +591,19 @@ export interface IPMarket extends BaseContract {
   ): Promise<ContractTransaction>;
 
   callStatic: {
+    _storage(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, number, number, number] & {
+        totalPt: BigNumber;
+        totalSy: BigNumber;
+        lastLnImpliedRate: BigNumber;
+        observationIndex: number;
+        observationCardinality: number;
+        observationCardinalityNext: number;
+      }
+    >;
+
     activeBalance(user: string, overrides?: CallOverrides): Promise<BigNumber>;
 
     allowance(
@@ -584,6 +657,17 @@ export interface IPMarket extends BaseContract {
 
     name(overrides?: CallOverrides): Promise<string>;
 
+    observations(
+      index: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [number, BigNumber, boolean] & {
+        blockTimestamp: number;
+        lnImpliedRateCumulative: BigNumber;
+        initialized: boolean;
+      }
+    >;
+
     observe(
       secondsAgos: BigNumberish[],
       overrides?: CallOverrides
@@ -731,6 +815,8 @@ export interface IPMarket extends BaseContract {
   };
 
   estimateGas: {
+    _storage(overrides?: CallOverrides): Promise<BigNumber>;
+
     activeBalance(user: string, overrides?: CallOverrides): Promise<BigNumber>;
 
     allowance(
@@ -776,6 +862,11 @@ export interface IPMarket extends BaseContract {
 
     name(overrides?: CallOverrides): Promise<BigNumber>;
 
+    observations(
+      index: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     observe(
       secondsAgos: BigNumberish[],
       overrides?: CallOverrides
@@ -825,6 +916,8 @@ export interface IPMarket extends BaseContract {
   };
 
   populateTransaction: {
+    _storage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     activeBalance(
       user: string,
       overrides?: CallOverrides
@@ -876,6 +969,11 @@ export interface IPMarket extends BaseContract {
 
     name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    observations(
+      index: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     observe(
       secondsAgos: BigNumberish[],
       overrides?: CallOverrides

package/typechain-types/IPPtOracle.ts

@@ -11,7 +11,7 @@ import {
   Signer,
   utils,
 } from "ethers";
-import { FunctionFragment, Result } from "@ethersproject/abi";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
 import { Listener, Provider } from "@ethersproject/providers";
 import type {
   TypedEventFilter,
@@ -45,9 +45,21 @@ export interface IPPtOracleInterface extends utils.Interface {
     data: BytesLike
   ): Result;
 
-  events: {};
+  events: {
+    "SetBlockCycleNumerator(uint16)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "SetBlockCycleNumerator"): EventFragment;
 }
 
+export type SetBlockCycleNumeratorEvent = TypedEvent<
+  [number],
+  { newBlockCycleNumerator: number }
+>;
+
+export type SetBlockCycleNumeratorEventFilter =
+  TypedEventFilter<SetBlockCycleNumeratorEvent>;
+
 export interface IPPtOracle extends BaseContract {
   contractName: "IPPtOracle";
   connect(signerOrProvider: Signer | Provider | string): this;
@@ -133,7 +145,14 @@ export interface IPPtOracle extends BaseContract {
     ): Promise<BigNumber>;
   };
 
-  filters: {};
+  filters: {
+    "SetBlockCycleNumerator(uint16)"(
+      newBlockCycleNumerator?: null
+    ): SetBlockCycleNumeratorEventFilter;
+    SetBlockCycleNumerator(
+      newBlockCycleNumerator?: null
+    ): SetBlockCycleNumeratorEventFilter;
+  };
 
   estimateGas: {
     getOracleState(

package/typechain-types/IPYieldToken.ts

@@ -39,6 +39,7 @@ export interface IPYieldTokenInterface extends utils.Interface {
     "mintPY(address,address)": FunctionFragment;
     "name()": FunctionFragment;
     "pyIndexCurrent()": FunctionFragment;
+    "pyIndexLastUpdatedBlock()": FunctionFragment;
     "pyIndexStored()": FunctionFragment;
     "redeemDueInterestAndRewards(address,bool,bool)": FunctionFragment;
     "redeemPY(address)": FunctionFragment;
@@ -84,6 +85,10 @@ export interface IPYieldTokenInterface extends utils.Interface {
     functionFragment: "pyIndexCurrent",
     values?: undefined
   ): string;
+  encodeFunctionData(
+    functionFragment: "pyIndexLastUpdatedBlock",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "pyIndexStored",
     values?: undefined
@@ -146,6 +151,10 @@ export interface IPYieldTokenInterface extends utils.Interface {
     functionFragment: "pyIndexCurrent",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "pyIndexLastUpdatedBlock",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "pyIndexStored",
     data: BytesLike
@@ -339,6 +348,8 @@ export interface IPYieldToken extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    pyIndexLastUpdatedBlock(overrides?: CallOverrides): Promise<[BigNumber]>;
+
     pyIndexStored(overrides?: CallOverrides): Promise<[BigNumber]>;
 
     redeemDueInterestAndRewards(
@@ -441,6 +452,8 @@ export interface IPYieldToken extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  pyIndexLastUpdatedBlock(overrides?: CallOverrides): Promise<BigNumber>;
+
   pyIndexStored(overrides?: CallOverrides): Promise<BigNumber>;
 
   redeemDueInterestAndRewards(
@@ -539,6 +552,8 @@ export interface IPYieldToken extends BaseContract {
 
     pyIndexCurrent(overrides?: CallOverrides): Promise<BigNumber>;
 
+    pyIndexLastUpdatedBlock(overrides?: CallOverrides): Promise<BigNumber>;
+
     pyIndexStored(overrides?: CallOverrides): Promise<BigNumber>;
 
     redeemDueInterestAndRewards(
@@ -728,6 +743,8 @@ export interface IPYieldToken extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    pyIndexLastUpdatedBlock(overrides?: CallOverrides): Promise<BigNumber>;
+
     pyIndexStored(overrides?: CallOverrides): Promise<BigNumber>;
 
     redeemDueInterestAndRewards(
@@ -826,6 +843,10 @@ export interface IPYieldToken extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    pyIndexLastUpdatedBlock(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     pyIndexStored(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     redeemDueInterestAndRewards(