@pendle/core-v2 4.6.0 → 4.7.1

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) = market.getSYandPYIndexCurrent();
         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) = market.getSYandPYIndexCurrent();
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
         if (syIndex >= pyIndex) {
             return lpToAssetRateRaw.divDown(syIndex);
@@ -76,11 +76,11 @@ library PendleLpOracleLib {
         MarketState memory state,
         uint32 duration
     ) private view returns (int256 rateOracle, int256 rateHypTrade) {
-        rateOracle = PMath.IONE.divDown(market.getPtToAssetRateRaw(duration).Int());
-        int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(
-            state.lastLnImpliedRate,
-            state.expiry - block.timestamp
-        );
+        uint256 lnImpliedRate = market.getMarketLnImpliedRate(duration);
+        uint256 timeToExpiry = state.expiry - block.timestamp;
+        rateOracle = MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry);
+
+        int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(state.lastLnImpliedRate, timeToExpiry);
         rateHypTrade = (rateLastTrade + rateOracle) / 2;
     }
 }

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,54 @@ contract PendlePtLpOracle is BoringOwnableUpgradeable, IPPtLpOracle {
     uint16 public blockCycleNumerator;
     uint16 public constant BLOCK_CYCLE_DENOMINATOR = 1000;
 
-    constructor(uint16 _blockCycleNumerator) initializer {
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(uint16 _blockCycleNumerator) external initializer {
         __BoringOwnable_init();
-        setBlockCycleNumerator(_blockCycleNumerator);
+        _setBlockCycleNumerator(_blockCycleNumerator);
     }
 
-    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) public onlyOwner {
-        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
-            revert InvalidBlockRate(newBlockCycleNumerator);
-        }
+    // Refer to https://docs.pendle.finance/Home on how to use the oracle
 
-        blockCycleNumerator = newBlockCycleNumerator;
-        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    /*///////////////////////////////////////////////////////////////
+                    PT, YT, LP to SY
+    //////////////////////////////////////////////////////////////*/
+
+    function getPtToSyRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getPtToSyRate(duration);
     }
 
-    function getPtToAssetRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getPtToAssetRate(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);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    PT, YT, LP to Asset
+    //////////////////////////////////////////////////////////////*/
+
     /// @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 getLpToAssetRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getLpToAssetRate(duration);
+    function getPtToAssetRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getPtToAssetRate(duration);
     }
 
-    function getPtToSyRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getPtToSyRate(duration);
+    function getYtToAssetRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getYtToAssetRate(duration);
     }
 
-    function getLpToSyRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getLpToSyRate(duration);
+    function getLpToAssetRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getLpToAssetRate(duration);
     }
 
+    /*///////////////////////////////////////////////////////////////
+                        Utility functions
+    //////////////////////////////////////////////////////////////*/
+
     /**
      * A check function for the cardinality status of the market
      * @param market PendleMarket address
@@ -99,4 +115,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();
@@ -42,13 +67,18 @@ library PendlePtOracleLib {
         if (expiry <= block.timestamp) {
             return PMath.ONE;
         } else {
-            uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
+            uint256 lnImpliedRate = getMarketLnImpliedRate(market, duration);
             uint256 timeToExpiry = expiry - block.timestamp;
             uint256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry).Uint();
             return PMath.ONE.divDown(assetToPtRate);
         }
     }
 
+    /// @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();
 
@@ -62,7 +92,7 @@ library PendlePtOracleLib {
         }
     }
 
-    function _getMarketLnImpliedRate(IPMarket market, uint32 duration) private view returns (uint256) {
+    function getMarketLnImpliedRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         uint32[] memory durations = new uint32[](2);
         durations[0] = duration;
 

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);
+        }
+    }
+}

package/deployments/1-core.json

@@ -32,7 +32,7 @@
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
     "pendleSwap": "0x1e8b6Ac39f8A33f46a6Eb2D1aCD1047B99180AD1",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "ptAndLpOracle": "0x66a1096C6366b2529274dF4f5D8247827fe4CEA8",
+    "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",
     "poolDeployHelper": "0x1E4c3DE54DecbD51F1F9a6b4eaFd265FAc04e831",

package/deployments/1-markets/MELLOW-AMPHRETH-MAINNET-JUL2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY amphrETH",
+    "SY": "0x198139F26d42F2028C10427a161e2d0e8bb00346",
+    "YT": "0x4dA430a0b5B22705ACFCC1bD5eE15603861ed98b",
+    "PT": "0x4CA48e7Dd3970F96EE74D6A573Ca5678EA1EB31b",
+    "market": "0x3B621df9B429Ed1AD64428Ea7d8D142374c45121",
+    "expiry": 1721865600,
+    "scalarRoot": "3752494233000000000",
+    "initAnchor": "1067376871000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0x4d40fd374690af4eb911381ef0aef2bd28530c25114b40ea2d689ada72fda5ea",
+    "deployBlockNumber": 20125481,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/1-markets/MELLOW-RE7LRT-MAINNET-JUL2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY re7LRT",
+    "SY": "0xE833C7A12A10A44Cb8b19BdF0931053AC136F105",
+    "YT": "0x44188731D5bb43d0AED555d29f1013AEb13bD4a2",
+    "PT": "0x2B91426E6F2A88B2C4Afc6c279fA8842A23EBD7F",
+    "market": "0x2a41384C28B3E327bEDA4ffB3D3706CAd571d5fb",
+    "expiry": 1721865600,
+    "scalarRoot": "3752494233000000000",
+    "initAnchor": "1067376871000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0xc69ac5b68a01608c098795393c4c711fe8457ee2cb7fc1867e75304d021e240e",
+    "deployBlockNumber": 20125478,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/1-markets/MELLOW-RSTETH-MAINNET-JUL2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY rstETH",
+    "SY": "0x553cD5e6D2072723f5FE5457576Ed6D06b0905b2",
+    "YT": "0xF04f1F279C9dA038b917538D89947f0E00672487",
+    "PT": "0x997949eEA781c04E4801d9c0902540236A317B07",
+    "market": "0xa96FeBd6c5FAF7739d3149bfB43211Ec6844a37C",
+    "expiry": 1721865600,
+    "scalarRoot": "3752494233000000000",
+    "initAnchor": "1067376871000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0x6260dcacdb1450829acb4c647057975d6aa67e9ffa10f7e6e6d78487231992b7",
+    "deployBlockNumber": 20125483,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/1-markets/MELLOW-STEAKLRT-MAINNET-JUL2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY steakLRT",
+    "SY": "0x998a1d40f097fd36bff15ca78fc0673bd2a8280c",
+    "YT": "0xC48276dd601C83234D767F4d7d0c1B2B32BC7632",
+    "PT": "0x2ED065f447971768c1117E4A36C80F4a54eb88FA",
+    "market": "0x464F5A15Aca6Fe787Cf54fCF1E8AF6207939d297",
+    "expiry": 1721865600,
+    "scalarRoot": "3752494233000000000",
+    "initAnchor": "1067376871000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0x1bb02ab40d309a2429c652759d794d4ee9a641cbb4cb6749442da911cc3c8fa9",
+    "deployBlockNumber": 20125476,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/1-markets/SILO-CRVUSD-MAINNET-SEP2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY crvUSD",
+    "SY": "0x60D1AfD87c5Ab1a13E27638f1e75277fEbF4908C",
+    "YT": "0x633dEfD7E79f94cDb77fe469f348Bd919c4b678a",
+    "PT": "0x48ee2348991A6b345B170bF5E92E2E5A16CF1edD",
+    "market": "0x386F90Eb964A477498b528a39D9405E73Ed4032b",
+    "expiry": 1727308800,
+    "scalarRoot": "11782157612000000000",
+    "initAnchor": "1075264122000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0xe5ee0468aeed20c82d18c404fbebdfc6eb138bb9368008019cd1300d23f0d69e",
+    "deployBlockNumber": 20066693,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/1-markets/WEETH-MAINNET-JUL2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY eETH",
+    "SY": "0xAC0047886a985071476a1186bE89222659970d65",
+    "YT": "0x9c73E0A1fA310e2BDC95AF1145B9D8Daa87bD9C0",
+    "PT": "0xe146E7018B3fb588c4EFbC2F211e8BB8d8C31c81",
+    "market": "0xe1F19CBDa26b6418B0C8E1EE978a533184496066",
+    "expiry": 1721865600,
+    "scalarRoot": "17824517489000000000",
+    "initAnchor": "1016465725000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0xfc4f5f039d8f073059045e6a2f2f9e0d94f9f8c6ef0d11993a3e2549574e66b4",
+    "deployBlockNumber": 20115781,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/1-markets/WEETHs-MAINNET-AUG2024.json

@@ -0,0 +1,15 @@
+{
+    "name": "WEETHs-MAINNET-AUG2024",
+    "SY": "0x9e8f10574ACc2c62C6e5d19500CEd39163Da37A9",
+    "YT": "0x28cE264D0938C1051687FEbDCeFacc2242BA9E0E",
+    "PT": "0xda6530EfaFD63A42d7b9a0a5a60A03839CDb813A",
+    "market": "0xcAa8ABB72A75C623BECe1f4D5c218F425d47A0D0",
+    "expiry": 1724889600,
+    "lnFeeRateRoot": "2995508979000000",
+    "scalarRoot": "5887618402000000000",
+    "initAnchor": "1078728622000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0xfa253a76ff6c8d75baa512b4aa86487a19963e509c8a0864fd63369e1de8824e",
+    "deployBlockNumber": 20123766,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/10-core.json

@@ -31,7 +31,7 @@
     "routerStatic": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
     "pendleSwap": "0x9B9f96786B1051F5c72c517e7DEB189CF66E704F",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "ptAndLpOracle": "0x15Aab5C1ab800A9e457d9f4335e8A2Dc9f6Ad707",
+    "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xfa6B22FC4c3Ad88B68c16b3061a16b1714F6Bd57",
     "marketFactoryV3": "0x4A2B38b9cBd83c86F261a4d64c243795D4d44aBC",
     "poolDeployHelper": "0xc4A9d8b486f388CC0E4168d2904277e8C8372FA3",

package/deployments/42161-core.json

@@ -31,7 +31,7 @@
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
     "pendleSwap": "0x63a45E0B2686F7be77Bb85735c35704D1046459a",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "ptAndLpOracle": "0x1Fd95db7B7C0067De8D45C0cb35D59796adfD187",
+    "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xEb38531db128EcA928aea1B1CE9E5609B15ba146",
     "marketFactoryV3": "0x2FCb47B58350cD377f94d3821e7373Df60bD9Ced",
     "poolDeployHelper": "0x644f83C584E9B109518726d5bEa3FF615548f88b",

package/deployments/42161-markets/AUSDC-ARBITRUM-DEC2024.json

@@ -0,0 +1,15 @@
+{
+    "name": "AUSDC-ARBITRUM-DEC2024",
+    "SY": "0x369751A0b33DF3adE5e2eE55e7bB9556B10F390C",
+    "YT": "0xF065e0f7AFA89DF5f2a8a109239C809f115129AE",
+    "PT": "0xBB47aD7f407CBD385C9269ebd0d1Eb1CB634cDfa",
+    "market": "0x875F154f4eC93255bEAEA9367c3AdF71Cdcb4Cc0",
+    "expiry": 1735171200,
+    "lnFeeRateRoot": "999500333000000",
+    "scalarRoot": "27962832412000000000",
+    "initAnchor": "1063018566000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0xd410faa4eb101a546a650b23663e7c8173932f2b326fa574357c058500c259b0",
+    "deployBlockNumber": 218890502,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/42161-markets/CAMELOT-PEP-ARBITRUM-JUNE2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY Camelot",
+    "SY": "0xc79d8a2aa6d769138e599d4dbc30569c9870a6ee",
+    "YT": "0x6382276be546b4816a72a9ef08c52575e569dda0",
+    "PT": "0xcef75d0914d183c8eadfafaea9dfef688aaffcf3",
+    "market": "0xe9e114d1b119bbdeb7a35e1ce3c82db01622ada2",
+    "expiry": 1750896000,
+    "scalarRoot": "13559889929000000000",
+    "initAnchor": "1206279539000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x3da72680ebb07a420f9e62854769dff7391abd72448916014bc95ef120a65b51",
+    "deployBlockNumber": 217875356,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/42161-markets/DOLOMITE-USDC-ARBITRUM-SEP2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY USDC",
+    "SY": "0x84E0efc0633041aac9D0196B7aC8aF3505e8CC32",
+    "YT": "0x916758e7605d0a4da4D9144e4e6fFc46E401eE67",
+    "PT": "0x9D17d67dDA1256c5dF78035ce6c8795eA3136E89",
+    "market": "0x2fB73D98B1D60B35FD12508933578098f352cE7e",
+    "expiry": 1727308800,
+    "scalarRoot": "9627908355000000000",
+    "initAnchor": "1085111203000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x233c6644d8ada66be22f4569db9169d315968d319169b5d78db5f665c0d6daa8",
+    "deployBlockNumber": 220943848,
+    "reversedFee": 0.09999999999164011
+}