@pendle/core-v2 4.5.1-beta-1 → 4.5.1-oracle-beta

package/contracts/interfaces/IPGovernanceProxy.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPGovernanceProxy {
+    struct Call {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+
+    function pause(address[] calldata addrs) external;
+
+    function aggregate(Call[] calldata calls) external payable returns (bytes[] memory rtnData);
+}

package/contracts/interfaces/{IPPtLpOracle.sol → IPPYLpOracle.sol}

@@ -1,15 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-interface IPPtLpOracle {
+interface IPPYLpOracle {
     event SetBlockCycleNumerator(uint16 newBlockCycleNumerator);
 
     function getPtToAssetRate(address market, uint32 duration) external view returns (uint256);
 
+    function getYtToAssetRate(address market, uint32 duration) external view returns (uint256);
+
     function getLpToAssetRate(address market, uint32 duration) external view returns (uint256);
 
     function getPtToSyRate(address market, uint32 duration) external view returns (uint256);
 
+    function getYtToSyRate(address market, uint32 duration) external view returns (uint256);
+
     function getLpToSyRate(address market, uint32 duration) external view returns (uint256);
 
     function getOracleState(

package/contracts/interfaces/IPPausingInterface.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPPausingInterface {
+    function pause() external;
+
+    function unpause() external;
+}

package/contracts/interfaces/Swell/ISwellSimpleStakingERC20.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+interface ISwellSimpleStakingERC20 {
+    /// @notice Struct to hold the supported booleans
+    /// @param deposit true if deposit is supported
+    /// @param withdraw true if withdraw is supported
+    struct Supported {
+        bool deposit;
+        bool withdraw;
+    }
+
+    /// @notice Error emitted when the amount is null
+    error AMOUNT_NULL();
+
+    /// @notice Error emitted when the address is null
+    error ADDRESS_NULL();
+
+    /// @notice Error emitted when the balance is insufficient
+    error INSUFFICIENT_BALANCE();
+
+    /// @notice Error emitted when the token is not allowed
+    error TOKEN_NOT_ALLOWED(address token);
+
+    /// @notice Event emitted when a token is added or removed
+    /// @param token address of the token
+    /// @param supported struct with deposit and withdraw booleans
+    event SupportedToken(address indexed token, Supported supported);
+
+    /// @notice Event emitted when a deposit is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the deposit
+    event Deposit(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Event emitted when a withdrawal is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the withdrawal
+    event Withdraw(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Method to deposit tokens
+    /// @dev token are transferred from the sender, and the receiver is credited
+    /// @param _token address of the token
+    /// @param _amount amount to deposit
+    /// @param _receiver address of the receiver
+    function deposit(address _token, uint256 _amount, address _receiver) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev difference between balance and internal balance is transferred to the owner
+    /// @param _token address of the token
+    function rescueERC20(address _token) external;
+
+    /// @notice Method to add or remove a token
+    /// @dev only callable by the owner
+    /// @param _token address of the token
+    /// @param _supported struct with deposit and withdraw booleans
+    function supportToken(address _token, Supported calldata _supported) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev token are transferred to the receiver and sender is credited
+    /// @param _token address of the token
+    /// @param _amount amount to withdraw
+    /// @param _receiver address of the receiver
+    function withdraw(address _token, uint256 _amount, address _receiver) external;
+}

package/contracts/offchain-helpers/PendleGovernanceProxy.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import "../interfaces/IPPausingInterface.sol";
+import "../interfaces/IPGovernanceProxy.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+// solhint-disable custom-errors
+// solhint-disable no-inline-assembly
+// solhint-disable no-empty-blocks
+
+contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPGovernanceProxy {
+    bytes32 public constant GUARDIAN = keccak256("GUARDIAN");
+
+    modifier onlyGuardian() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || hasRole(GUARDIAN, msg.sender), "not authorized");
+        _;
+    }
+
+    modifier onlyAdmin() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not authorized");
+        _;
+    }
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                PAUSING
+    //////////////////////////////////////////////////////////////*/
+
+    function pause(address[] calldata addrs) external onlyGuardian {
+        uint256 length = addrs.length;
+        for (uint256 i = 0; i < length; ) {
+            IPPausingInterface(addrs[i]).pause();
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            ADMIN CALL
+    //////////////////////////////////////////////////////////////*/
+
+    function aggregate(
+        IPGovernanceProxy.Call[] calldata calls
+    ) external payable onlyAdmin returns (bytes[] memory rtnData) {
+        uint256 length = calls.length;
+        rtnData = new bytes[](length);
+
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call{value: call.value}(call.callData);
+            if (!success) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            rtnData[i] = resp;
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    receive() external payable {}
+
+    /*///////////////////////////////////////////////////////////////
+                            UPGRADABLE RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function initialize(address governance) external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, governance);
+    }
+
+    function _authorizeUpgrade(address) internal view override onlyAdmin {}
+}

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -114,12 +114,20 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     function getLpToAssetRate(address market) public view returns (uint256) {
         MarketState memory state = _readState(market);
         PYIndex pyIndexCurrent = _pyIndex(market);
-        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
 
-        int256 totalHypotheticalAsset = comp.totalAsset +
-            state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+        int256 totalHypotheticalAsset;
+        if (state.expiry <= block.timestamp) {
+            // 1 PT = 1 Asset post-expiry
+            totalHypotheticalAsset = state.totalPt + pyIndexCurrent.syToAsset(state.totalSy);
+        } else {
+            MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
+
+            totalHypotheticalAsset =
+                comp.totalAsset +
+                state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
+        }
 
-        return uint256(totalHypotheticalAsset.divDown(state.totalLp));
+        return totalHypotheticalAsset.divDown(state.totalLp).Uint();
     }
 
     function getPtToAssetRate(address market) public view returns (uint256) {

package/contracts/oracles/PendleLpOracleLib.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "./PendlePtOracleLib.sol";
+import "./PendlePYOracleLib.sol";
 
 library PendleLpOracleLib {
-    using PendlePtOracleLib for IPMarket;
+    using PendlePYOracleLib for IPMarket;
     using PMath for uint256;
     using PMath for int256;
     using MarketMathCore for MarketState;
@@ -16,7 +16,7 @@ library PendleLpOracleLib {
      * @param duration twap duration
      */
     function getLpToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
-        (uint256 syIndex, uint256 pyIndex) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
+        (uint256 syIndex, uint256 pyIndex) = PendlePYOracleLib.getSYandPYIndexCurrent(market);
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
         if (syIndex >= pyIndex) {
             return lpToAssetRateRaw;
@@ -32,7 +32,7 @@ library PendleLpOracleLib {
      * @param duration twap duration
      */
     function getLpToSyRate(IPMarket market, uint32 duration) internal view returns (uint256) {
-        (uint256 syIndex, uint256 pyIndex) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
+        (uint256 syIndex, uint256 pyIndex) = PendlePYOracleLib.getSYandPYIndexCurrent(market);
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
         if (syIndex >= pyIndex) {
             return lpToAssetRateRaw.divDown(syIndex);

package/contracts/oracles/{PendlePtLpOracle.sol → PendlePYLpOracle.sol}

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./PendlePtOracleLib.sol";
+import "./PendlePYOracleLib.sol";
 import "./PendleLpOracleLib.sol";
-import "../interfaces/IPPtLpOracle.sol";
+import "../interfaces/IPPYLpOracle.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";
 
 // This is a pre-deployed version of PendlePtOracleLib & PendleLpOracleLib with additional utility functions.
 // Use of this contract rather than direct library integration resulting in a smaller bytecode size and simpler structure
 // but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
-contract PendlePtLpOracle is BoringOwnableUpgradeable, IPPtLpOracle {
-    using PendlePtOracleLib for IPMarket;
+contract PendlePYLpOracle is BoringOwnableUpgradeable, IPPYLpOracle {
+    using PendlePYOracleLib for IPMarket;
     using PendleLpOracleLib for IPMarket;
 
     error InvalidBlockRate(uint256 blockCycleNumerator);
@@ -26,38 +26,52 @@ contract PendlePtLpOracle is BoringOwnableUpgradeable, IPPtLpOracle {
     uint16 public blockCycleNumerator;
     uint16 public constant BLOCK_CYCLE_DENOMINATOR = 1000;
 
-    constructor(uint16 _blockCycleNumerator) initializer {
-        __BoringOwnable_init();
-        setBlockCycleNumerator(_blockCycleNumerator);
+    constructor(uint16 _blockCycleNumerator) {
+        _setBlockCycleNumerator(_blockCycleNumerator);
     }
 
-    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) public onlyOwner {
-        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
-            revert InvalidBlockRate(newBlockCycleNumerator);
-        }
-
-        blockCycleNumerator = newBlockCycleNumerator;
-        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    function initialize() external initializer {
+        __BoringOwnable_init();
     }
 
+    /*///////////////////////////////////////////////////////////////
+                    PT, YT, LP to Asset (see EIP-5115)
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice make sure you have taken into account the risk of not being able to withdraw from SY to Asset
+    /// More info in StandardizedYield
     function getPtToAssetRate(address market, uint32 duration) external view returns (uint256) {
         return IPMarket(market).getPtToAssetRate(duration);
     }
 
-    /// @notice make sure you have taken into account the risk of not being able to withdraw from SY to Asset
-    /// More info in StandardizedYield
+    function getYtToAssetRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getYtToAssetRate(duration);
+    }
+
     function getLpToAssetRate(address market, uint32 duration) external view returns (uint256) {
         return IPMarket(market).getLpToAssetRate(duration);
     }
 
+    /*///////////////////////////////////////////////////////////////
+                    PT, YT, LP to SY (repricing token)
+    //////////////////////////////////////////////////////////////*/
+
     function getPtToSyRate(address market, uint32 duration) external view returns (uint256) {
         return IPMarket(market).getPtToSyRate(duration);
     }
 
+    function getYtToSyRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getYtToSyRate(duration);
+    }
+
     function getLpToSyRate(address market, uint32 duration) external view returns (uint256) {
         return IPMarket(market).getLpToSyRate(duration);
     }
 
+    /*///////////////////////////////////////////////////////////////
+                        Utility functions
+    //////////////////////////////////////////////////////////////*/
+
     /**
      * A check function for the cardinality status of the market
      * @param market PendleMarket address
@@ -99,4 +113,18 @@ contract PendlePtLpOracle is BoringOwnableUpgradeable, IPPtLpOracle {
         }
         return uint16(cardinalityRequired);
     }
+
+    // --- Owner-Only Functions ---
+    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) external onlyOwner {
+        _setBlockCycleNumerator(newBlockCycleNumerator);
+    }
+
+    function _setBlockCycleNumerator(uint16 newBlockCycleNumerator) internal {
+        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
+            revert InvalidBlockRate(newBlockCycleNumerator);
+        }
+
+        blockCycleNumerator = newBlockCycleNumerator;
+        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    }
 }

package/contracts/oracles/{PendlePtOracleLib.sol → PendlePYOracleLib.sol}

@@ -6,7 +6,7 @@ import "../core/libraries/math/PMath.sol";
 
 // This library can & should be integrated directly for optimal gas usage.
 // If you prefer not to integrate it directly, the PendlePtOracle contract (a pre-deployed version of this contract) can be used.
-library PendlePtOracleLib {
+library PendlePYOracleLib {
     using PMath for uint256;
     using PMath for int256;
 
@@ -25,6 +25,21 @@ library PendlePtOracleLib {
         }
     }
 
+    /**
+     * This function returns the twap rate YT/Asset on market, but take into account the current rate of SY
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getYtToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
+        (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
+        if (syIndex >= pyIndex) {
+            return getYtToAssetRateRaw(market, duration);
+        } else {
+            return (getYtToAssetRateRaw(market, duration) * syIndex) / pyIndex;
+        }
+    }
+
     /// @notice Similar to getPtToAsset but returns the rate in SY instead
     function getPtToSyRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
@@ -35,6 +50,16 @@ library PendlePtOracleLib {
         }
     }
 
+    /// @notice Similar to getPtToAsset but returns the rate in SY instead
+    function getYtToSyRate(IPMarket market, uint32 duration) internal view returns (uint256) {
+        (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
+        if (syIndex >= pyIndex) {
+            return getYtToAssetRateRaw(market, duration).divDown(syIndex);
+        } else {
+            return getYtToAssetRateRaw(market, duration).divDown(pyIndex);
+        }
+    }
+
     /// @notice returns the raw rate without taking into account whether SY is solvent
     function getPtToAssetRateRaw(IPMarket market, uint32 duration) internal view returns (uint256) {
         uint256 expiry = market.expiry();
@@ -49,6 +74,11 @@ library PendlePtOracleLib {
         }
     }
 
+    /// @notice returns the raw rate without taking into account whether SY is solvent
+    function getYtToAssetRateRaw(IPMarket market, uint32 duration) internal view returns (uint256) {
+        return PMath.ONE - getPtToAssetRateRaw(market, duration);
+    }
+
     function getSYandPYIndexCurrent(IPMarket market) internal view returns (uint256 syIndex, uint256 pyIndex) {
         (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
 

package/contracts/oracles/samples/BoringLpGlpOracle.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.17;
 
 import "../PendleLpOracleLib.sol";
-import "../../interfaces/IPPtLpOracle.sol";
+import "../../interfaces/IPPYLpOracle.sol";
 import "../../interfaces/GMX/IGlpManager.sol";
 import "../../core/libraries/math/PMath.sol";
 
@@ -23,7 +23,7 @@ contract BoringLpGlpOracle {
         market = _market;
         glpManager = _glpManager;
 
-        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtLpOracle(_ptOracle).getOracleState(
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPYLpOracle(_ptOracle).getOracleState(
             market,
             twapDuration
         );

package/contracts/oracles/samples/{BoringPtUsdChainlinkOracle.sol → BoringPYUsdChainlinkAssetOracle.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../interfaces/IPPtLpOracle.sol";
+import "../../interfaces/IPPYLpOracle.sol";
 import "../../interfaces/IPMarket.sol";
 import "../../core/libraries/math/PMath.sol";
 import "../PendleLpOracleLib.sol";
@@ -9,29 +9,41 @@ import "../PendleLpOracleLib.sol";
 import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 /**
- * @notice The returned price from this contract is multiplied by the default USD price of the asset, as read from Chainlink Oracles.
- * For more details into how the oracle is implemented, refer to PendlePtOracle & PendlePtOracleLib.
+ * @notice The returned price from this contract is multiplied by the default USD price of the
+ * underlying asset, as read from a Chainlink-interface oracle.
+ *
+ * Example of this usage:
+ * - PT-wstETH = ptToAssetRate * stETH price
+ * - PT-silo-crvUSD = ptToAssetRate * crvUSD price
+ *
+ * For more details into how the oracle is implemented, refer to PendlePYLpOracle & PendlePYOracleLib.
  */
-contract BoringPtUsdChainlinkOracle {
-    using PendlePtOracleLib for IPMarket;
+contract BoringPYUsdChainlinkAssetOracle {
+    using PendlePYOracleLib for IPMarket;
 
     uint32 public immutable twapDuration;
     address public immutable market;
     address public immutable feed;
     uint8 public immutable feedDecimals;
-    address public immutable ptOracle;
+    address public immutable pyLpOracle;
 
-    constructor(uint32 _twapDuration, address _market, address _feed, address _ptOracle) {
+    constructor(uint32 _twapDuration, address _market, address _feed, address _pyLpOracle) {
         twapDuration = _twapDuration;
         market = _market;
         feed = _feed;
         feedDecimals = IChainlinkAggregator(feed).decimals();
 
         // required only for sample2
-        ptOracle = _ptOracle;
+        pyLpOracle = _pyLpOracle;
+
+        /**
+         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran successfully without reverting.
+         * This equals to calling checkOracleState() in your oracle constructor.
+         */
+        // checkOracleState();
     }
 
-    /// @notice direct integration with PendlePtOracleLib, which optimizes gas efficiency.
+    /// @notice direct integration with PendlePYOracleLib, which optimizes gas efficiency.
     /// @notice please checkOracleState() before use
     function getPtPriceSample1() external view virtual returns (uint256) {
         uint256 ptRate = IPMarket(market).getPtToAssetRate(twapDuration);
@@ -43,11 +55,23 @@ contract BoringPtUsdChainlinkOracle {
     /// but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
     /// @notice please checkOracleState() before use
     function getPtPriceSample2() external view virtual returns (uint256) {
-        uint256 ptRate = IPPtLpOracle(ptOracle).getPtToAssetRate(market, twapDuration);
+        uint256 ptRate = IPPYLpOracle(pyLpOracle).getPtToAssetRate(market, twapDuration);
         uint256 assetPrice = _getUnderlyingAssetPrice();
         return (assetPrice * ptRate) / PMath.ONE;
     }
 
+    function getYtPriceSample1() external view virtual returns (uint256) {
+        uint256 ytRate = IPMarket(market).getYtToAssetRate(twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ytRate) / PMath.ONE;
+    }
+
+    function getYtPriceSample2() external view virtual returns (uint256) {
+        uint256 ytRate = IPPYLpOracle(pyLpOracle).getYtToAssetRate(market, twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ytRate) / PMath.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);
@@ -60,8 +84,8 @@ contract BoringPtUsdChainlinkOracle {
 
     /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any shorter duration).
     function checkOracleState() external view {
-        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPtLpOracle(
-            ptOracle
+        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
         ).getOracleState(market, twapDuration);
 
         if (increaseCardinalityRequired) {

package/contracts/oracles/samples/BoringPYUsdChainlinkSYOracle.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IPPYLpOracle.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../core/libraries/math/PMath.sol";
+import "../PendleLpOracleLib.sol";
+
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+/**
+ * @notice The returned price from this contract is multiplied by the default USD price of the
+ * SY-equivalent token, as read from a Chainlink-interface oracle.
+ *
+ * Example of this usage:
+ * - PT-weETH = ptToSyRate * weETH price
+ * - PT-ezETH = ptToSyRate * ezETH price
+ *
+ * For more details into how the oracle is implemented, refer to PendlePYLpOracle & PendlePYOracleLib.
+ */
+contract BoringPYUsdChainlinkSYOracle {
+    using PendlePYOracleLib for IPMarket;
+
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable feed;
+    uint8 public immutable feedDecimals;
+    address public immutable pyLpOracle;
+
+    constructor(uint32 _twapDuration, address _market, address _feed, address _pyLpOracle) {
+        twapDuration = _twapDuration;
+        market = _market;
+        feed = _feed;
+        feedDecimals = IChainlinkAggregator(feed).decimals();
+
+        // required only for sample2
+        pyLpOracle = _pyLpOracle;
+
+        /**
+         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran successfully without reverting.
+         * This equals to calling checkOracleState() in your oracle constructor.
+         */
+        // checkOracleState();
+    }
+
+    /// @notice direct integration with PendlePYOracleLib, which optimizes gas efficiency.
+    /// @notice please checkOracleState() before use
+    function getPtPriceSample1() external view virtual returns (uint256) {
+        uint256 ptRate = IPMarket(market).getPtToSyRate(twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ptRate) / PMath.ONE;
+    }
+
+    /// @notice integration with the PendlePtOracle contract, resulting in a smaller bytecode size and simpler structure
+    /// but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
+    /// @notice please checkOracleState() before use
+    function getPtPriceSample2() external view virtual returns (uint256) {
+        uint256 ptRate = IPPYLpOracle(pyLpOracle).getPtToSyRate(market, twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ptRate) / PMath.ONE;
+    }
+
+    function getYtPriceSample1() external view virtual returns (uint256) {
+        uint256 ytRate = IPMarket(market).getYtToSyRate(twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ytRate) / PMath.ONE;
+    }
+
+    function getYtPriceSample2() external view virtual returns (uint256) {
+        uint256 ytRate = IPPYLpOracle(pyLpOracle).getYtToSyRate(market, twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ytRate) / PMath.ONE;
+    }
+
+    function _getSYEquivalentTokenPrice() internal view virtual returns (uint256) {
+        uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
+        return feedDecimals < 18 ? rawPrice * 10 ** (18 - feedDecimals) : rawPrice / 10 ** (feedDecimals - 18);
+    }
+
+    // ------------------ NOT TO INCLUDE IN PRODUCTION CODE ------------------
+
+    error IncreaseCardinalityRequired(uint16 cardinalityRequired);
+    error AdditionalWaitRequired(uint32 duration);
+
+    /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any shorter duration).
+    function checkOracleState() external view {
+        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired) {
+            // It's required to call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) and wait for
+            // at least the twapDuration, to allow data population.
+            revert IncreaseCardinalityRequired(cardinalityRequired);
+        }
+
+        if (!oldestObservationSatisfied) {
+            // It's necessary to wait for at least the twapDuration, to allow data population.
+            revert AdditionalWaitRequired(twapDuration);
+        }
+    }
+}