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

package/contracts/interfaces/IPMarket.sol

@@ -84,4 +84,23 @@ interface IPMarket is IERC20Metadata, IPGauge {
     function isExpired() external view returns (bool);
 
     function expiry() external view returns (uint256);
+
+    function observations(
+        uint256 index
+    )
+        external
+        view
+        returns (uint32 blockTimestamp, uint216 lnImpliedRateCumulative, bool initialized);
+
+    function _storage()
+        external
+        view
+        returns (
+            int128 totalPt,
+            int128 totalSy,
+            uint96 lastLnImpliedRate,
+            uint16 observationIndex,
+            uint16 observationCardinality,
+            uint16 observationCardinalityNext
+        );
 }

package/contracts/interfaces/IPPtOracle.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPPtOracle {
+    event SetBlockCycleNumerator(uint16 newBlockCycleNumerator);
+
+    function getPtToAssetRate(
+        address market,
+        uint32 duration
+    ) external view returns (uint256 ptToAssetRate);
+
+    function getOracleState(
+        address market,
+        uint32 duration
+    )
+        external
+        view
+        returns (
+            bool increaseCardinalityRequired,
+            uint16 cardinalityRequired,
+            bool oldestObservationSatisfied
+        );
+}

package/contracts/interfaces/IPYieldToken.sol

@@ -62,4 +62,7 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
     function isExpired() external view returns (bool);
 
     function doCacheIndexSameBlock() external view returns (bool);
+
+    function pyIndexLastUpdatedBlock() external view returns (uint128);
+
 }

package/contracts/offchain-helpers/BoringPtSeller.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../interfaces/IPMarket.sol";
+
+abstract contract BoringPtSeller {
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    constructor() {}
+
+    /// @dev slippage control should be done on a higher level with the returned parameter
+    /// @param market market address
+    /// @param netPtIn amount of Pt to sell
+    /// @param tokenOut should be included in SY.getTokensOut()
+    /// @return netTokenOut amount of token out
+    function _sellPtForToken(
+        address market,
+        uint256 netPtIn,
+        address tokenOut
+    ) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        uint256 netSyOut;
+        if (PT.isExpired()) {
+            PT.transfer(address(YT), netPtIn);
+            netSyOut = YT.redeemPY(address(SY));
+        } else {
+            // safeTransfer not required
+            PT.transfer(market, netPtIn);
+            (netSyOut, ) = IPMarket(market).swapExactPtForSy(
+                address(SY), // better gas optimization to transfer SY directly to itself and burn
+                netPtIn,
+                EMPTY_BYTES
+            );
+        }
+
+        netTokenOut = SY.redeem(address(this), netSyOut, tokenOut, 0, true);
+    }
+}

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract EmptyUUPS is Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+    constructor() initializer {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/oracles/PendlePtOracle.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./PendlePtOracleLib.sol";
+import "../interfaces/IPPtOracle.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
+    using PendlePtOracleLib for IPMarket;
+
+    error InvalidBlockRate(uint256 blockCycleNumerator);
+    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
+
+    /// @notice Oracles will be created ensuring a lowerbound in PendleMarket oracle's cardinality
+    /// @dev Cardinality lowerbound will be calculated as twap_duration * 1000 / blockCycleNumerator
+    /// @dev blockCycleNumerator should be configured so that blockCycleNumerator / 1000 < actual block cycle
+    /// @dev blockCycleNumerator should be greater or equal to 1000 since the oracle only records one
+    /// rate per timestamp
+    /// For example, on Ethereum blockCycleNumerator = 11000, where 11000/1000 = 11 < 12
+    ///                 Arbitrum blockCycleNumerator = 1000, since we can't do better than this
+    uint16 public blockCycleNumerator;
+    uint16 public constant BLOCK_CYCLE_DENOMINATOR = 1000;
+
+    constructor(uint16 _blockCycleNumerator) initializer {
+        __BoringOwnable_init();
+        setBlockCycleNumerator(_blockCycleNumerator);
+    }
+
+    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) public onlyOwner {
+        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
+            revert InvalidBlockRate(newBlockCycleNumerator);
+        }
+
+        blockCycleNumerator = newBlockCycleNumerator;
+        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    }
+
+    /**
+     * This function returns the twap rate PT/Asset on market
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getPtToAssetRate(
+        address market,
+        uint32 duration
+    ) external view returns (uint256 ptToAssetRate) {
+        ptToAssetRate = IPMarket(market).getPtToAssetRate(duration);
+    }
+
+    /**
+     * A check function for the cardinality status of the market
+     * @param market PendleMarket address
+     * @param duration twap duration
+     * @return increaseCardinalityRequired a boolean indicates whether the cardinality should be increased to serve the duration
+     * @return cardinalityRequired the amount of cardinality required for the twap duration
+     */
+    function getOracleState(
+        address market,
+        uint32 duration
+    )
+        external
+        view
+        returns (
+            bool increaseCardinalityRequired,
+            uint16 cardinalityRequired,
+            bool oldestObservationSatisfied
+        )
+    {
+        (
+            ,
+            ,
+            ,
+            uint16 observationIndex,
+            uint16 observationCardinality,
+            uint16 cardinalityReserved
+        ) = IPMarket(market)._storage();
+
+        // checkIncreaseCardinalityRequired
+        cardinalityRequired = _calcCardinalityRequiredRequired(duration);
+        increaseCardinalityRequired = cardinalityReserved < cardinalityRequired;
+
+        // check oldestObservationSatisfied
+        (uint32 oldestTimestamp, , bool initialized) = IPMarket(market).observations(
+            (observationIndex + 1) % observationCardinality
+        );
+        if (!initialized) {
+            (oldestTimestamp, , ) = IPMarket(market).observations(0);
+        }
+        oldestObservationSatisfied = oldestTimestamp < block.timestamp - duration;
+    }
+
+    function _calcCardinalityRequiredRequired(uint32 duration) internal view returns (uint16) {
+        uint32 cardinalityRequired = (duration * BLOCK_CYCLE_DENOMINATOR) / blockCycleNumerator;
+        if (cardinalityRequired > type(uint16).max) {
+            revert TwapDurationTooLarge(duration, cardinalityRequired);
+        }
+        return uint16(cardinalityRequired);
+    }
+}

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) / (10 ** 30);
+    }
+
+    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,12 @@
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
     "pendleSwap": "0x38812C3AC3563Bf200482ac9D096952D7cB55f9b",
+    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
+    "ptOracle": "0x414d3C8A26157085f286abE3BC6E1bb010733602",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
     "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
-    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335"
+    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9"
 }

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.10.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"
   }