@pendle/core-v2 2.6.0-mainnet → 2.8.0-mainnet

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWethStafiEthSY.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
+import "../../../../interfaces/IWETH.sol";
+import "./base/MetaStable/MetaStablePreview.sol";
+
+contract PendleAuraWethStafiEthSY is PendleAuraBalancerStableLPSYV2 {
+    address internal constant STAFI_ETH = 0x9559Aaa82d9649C7A7b220E7c461d2E74c9a3593;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+
+    uint256 internal constant AURA_PID = 63;
+    address internal constant LP = 0xB08885e6026bab4333A80024Ec25a1a3e1FF2b8A;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        MetaStablePreview _previewHelper
+    ) PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE) {
+            IWETH(WETH).deposit{ value: amount }();
+            amountSharesOut = super._deposit(WETH, amount);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        if (tokenOut == NATIVE) {
+            uint256 amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
+            IWETH(WETH).withdraw(amountTokenOut);
+            _transferOut(NATIVE, receiver, amountTokenOut);
+            return amountTokenOut;
+        } else {
+            return super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE) {
+            amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
+        } else {
+            amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == NATIVE) {
+            amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
+        } else {
+            amountTokenOut = super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getPoolTokenAddresses()
+        internal
+        view
+        virtual
+        override
+        returns (address[] memory res)
+    {
+        res = new address[](2);
+        res[0] = STAFI_ETH;
+        res[1] = WETH;
+    }
+
+    function _getRateProviders() internal view virtual returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = 0x3D40f9dd83bd404fA4047c15da494E58C3c1f1ac;
+        res[1] = 0x0000000000000000000000000000000000000000;
+    }
+
+    function _getRawScalingFactors() internal view virtual returns (uint256[] memory res) {
+        res = new uint256[](2);
+        res[0] = 1e18;
+        res[1] = 1e18;
+    }
+
+    function _getImmutablePoolData() internal view virtual override returns (bytes memory) {
+        MetaStablePreview.ImmutableData memory res;
+        res.LP = LP;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+
+        return abi.encode(res);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = STAFI_ETH;
+        res[2] = WETH;
+        res[3] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = STAFI_ETH;
+        res[2] = WETH;
+        res[3] = NATIVE;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return (token == LP || token == STAFI_ETH || token == WETH || token == NATIVE);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return (token == LP || token == STAFI_ETH || token == WETH || token == NATIVE);
+    }
+}

package/contracts/core/StandardizedYield/implementations/BalancerStable/{PendleAuraWethWstethSY.sol → PendleAuraWethWstethSYV2.sol}

@@ -2,11 +2,11 @@
 pragma solidity 0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./base/PendleAuraBalancerStableLPSY.sol";
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
 import "../../StEthHelper.sol";
 import "./base/MetaStable/MetaStablePreview.sol";
 
-contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
+contract PendleAuraWethWstethSYV2 is PendleAuraBalancerStableLPSYV2, StEthHelper {
     uint256 internal constant AURA_PID = 29;
     address internal constant LP = 0x32296969Ef14EB0c6d29669C550D4a0449130230;
 
@@ -14,12 +14,14 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         string memory _name,
         string memory _symbol,
         MetaStablePreview _previewHelper
-    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) StEthHelper() {}
+    ) PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _previewHelper) StEthHelper() {}
 
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             IWETH(WETH).deposit{ value: amount }();
             amountSharesOut = super._deposit(WETH, amount);
@@ -48,10 +50,13 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         }
     }
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
         } else if (tokenIn == STETH) {
@@ -62,10 +67,13 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         }
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view virtual override returns (uint256 amountTokenOut) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
         if (tokenOut == NATIVE) {
             amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
         } else if (tokenOut == STETH) {

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/{PendleAuraBalancerStableLPSY.sol → PendleAuraBalancerStableLPSYV2.sol}

@@ -14,13 +14,13 @@ import "./StablePoolUserData.sol";
 import "../../../../libraries/ArrayLib.sol";
 import "../../../SYBaseWithRewards.sol";
 
-abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
+abstract contract PendleAuraBalancerStableLPSYV2 is SYBaseWithRewards {
     using ArrayLib for address[];
 
-    address public constant BAL_TOKEN = 0xba100000625a3754423978a60c9317c58a424e3D;
-    address public constant AURA_TOKEN = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
-    address public constant AURA_BOOSTER = 0xA57b8d98dAE62B26Ec3bcC4a365338157060B234;
-    address public constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
+    address internal constant BAL_TOKEN = 0xba100000625a3754423978a60c9317c58a424e3D;
+    address internal constant AURA_TOKEN = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
+    address internal constant AURA_BOOSTER = 0xA57b8d98dAE62B26Ec3bcC4a365338157060B234;
+    address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
 
     address public immutable balLp;
     bytes32 public immutable balPoolId;
@@ -55,9 +55,11 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         previewHelper = _previewHelper;
     }
 
-    function _getPoolInfo(
-        uint256 _auraPid
-    ) internal view returns (address _auraLp, address _auraRewardManager) {
+    function _getPoolInfo(uint256 _auraPid)
+        internal
+        view
+        returns (address _auraLp, address _auraRewardManager)
+    {
         if (_auraPid > IBooster(AURA_BOOSTER).poolLength()) revert Errors.SYBalancerInvalidPid();
         (_auraLp, , , _auraRewardManager, , ) = IBooster(AURA_BOOSTER).poolInfo(_auraPid);
     }
@@ -69,10 +71,12 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
     /**
      * @notice Either wraps LP, or also joins pool using exact tokenIn
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == balLp) {
             amountSharesOut = amount;
         } else {
@@ -100,17 +104,42 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
     }
 
     function exchangeRate() external view override returns (uint256) {
+        _checkBalancerReadOnlyReentrancy();
         return IRateProvider(balLp).getRate();
     }
 
+    /// @dev The `manageUserBalance` function is a non-view function that includes a reentrancy guard.
+    /// When it is called by `staticcall`, one of two cases can occur:
+    /// 1. The function passes the reentrancy guard. In this scenario, the `status` variable is set to 2,
+    /// causing the EVM to panic (since the sub-call is a `staticcall`), resulting in a revert with
+    /// no response (i.e., `response.length == 0`).
+    /// 2. The function does not pass the reentrancy guard. In this situation, it reverts due to
+    /// error `BAL#400`, which means that `response.length = 100.`
+    /// To prevent read-only reentrancy, we simply need to verify that the revert corresponds to case 1,
+    /// rather than case 2. checking `response.length == 0` is sufficient.
+    function _checkBalancerReadOnlyReentrancy() internal view {
+        IVault.UserBalanceOp[] memory noop = new IVault.UserBalanceOp[](0);
+
+        (bool isSuccess, bytes memory response) = BALANCER_VAULT.staticcall(
+            abi.encodeWithSignature(
+                "manageUserBalance((uint8,address,uint256,address,address)[])",
+                noop
+            )
+        );
+
+        assert(!isSuccess);
+        if (response.length != 0) revert Errors.SYBalancerReentrancy();
+    }
+
     /*///////////////////////////////////////////////////////////////
                     BALANCER-RELATED FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function _depositToBalancer(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal virtual returns (uint256) {
+    function _depositToBalancer(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        virtual
+        returns (uint256)
+    {
         IVault.JoinPoolRequest memory request = _assembleJoinRequest(
             tokenIn,
             amountTokenToDeposit
@@ -121,10 +150,12 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         return _selfBalance(balLp);
     }
 
-    function _assembleJoinRequest(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual returns (IVault.JoinPoolRequest memory request) {
+    function _assembleJoinRequest(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        returns (IVault.JoinPoolRequest memory request)
+    {
         // max amounts in
         address[] memory assets = _getPoolTokenAddresses();
 
@@ -166,10 +197,12 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         return balanceAfter - balanceBefore;
     }
 
-    function _assembleExitRequest(
-        address tokenOut,
-        uint256 amountLpToRedeem
-    ) internal view virtual returns (IVault.ExitPoolRequest memory request) {
+    function _assembleExitRequest(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        view
+        virtual
+        returns (IVault.ExitPoolRequest memory request)
+    {
         address[] memory assets = _getPoolTokenAddresses();
         uint256[] memory minAmountsOut = new uint256[](assets.length);
 
@@ -201,10 +234,13 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
                    PREVIEW FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == balLp) {
             amountSharesOut = amountTokenToDeposit;
         } else {
@@ -222,10 +258,13 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         }
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view virtual override returns (uint256 amountTokenOut) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
         if (tokenOut == balLp) {
             amountTokenOut = amountSharesToRedeem;
         } else {
@@ -303,7 +342,11 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
     function assetInfo()
         external
         view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
     {
         return (AssetType.LIQUIDITY, balLp, IERC20Metadata(balLp).decimals());
     }

package/contracts/core/StandardizedYield/implementations/PendleSfrxEthSY.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/Frax/IFrxEthMinter.sol";
+import "../../../interfaces/IERC4626.sol";
+
+/// @dev deposit through weth is not neccessary to be done on this contract's level
+/// as we already supported this with our router
+contract PendleSfrxEthSY is SYBase {
+    address public immutable minter;
+    address public immutable frxETH;
+    address public immutable sfrxETH;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _minter
+    ) SYBase(_name, _symbol, IFrxEthMinter(_minter).sfrxETHToken()) {
+        minter = _minter;
+        sfrxETH = IFrxEthMinter(minter).sfrxETHToken();
+        frxETH = IFrxEthMinter(minter).frxETHToken();
+
+        _safeApproveInf(frxETH, sfrxETH);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The underlying yield token is frxETH. If the base token deposited is ETH, the function
+     * deposits through fraxMinterContract - the most efficient way to get frxETH and deposit
+     * directly to sfrxETH.
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            return IFrxEthMinter(minter).submitAndDeposit{ value: amountDeposited }(address(this));
+        } else if (tokenIn == frxETH) {
+            return IERC4626(sfrxETH).deposit(amountDeposited, address(this));
+        } else {
+            return amountDeposited;
+        }
+    }
+
+    /**
+     * Withdrawal to sfrxETH and frxETH is done normally as other ERC4626.
+     * Withdrawal to ETH is on the other hand not possible
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == sfrxETH) {
+            _transferOut(sfrxETH, receiver, amountSharesToRedeem);
+            return amountSharesToRedeem;
+        } else {
+            return IERC4626(sfrxETH).redeem(amountSharesToRedeem, receiver, address(this));
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of sfrxETH to frxETH
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(sfrxETH).convertToAssets(1 ether);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == sfrxETH) {
+            return amountTokenToDeposit;
+        } else {
+            return IERC4626(sfrxETH).previewDeposit(amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == sfrxETH) {
+            return amountSharesToRedeem;
+        } else {
+            return IERC4626(sfrxETH).convertToAssets(amountSharesToRedeem);
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = frxETH;
+        res[1] = sfrxETH;
+        res[2] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = frxETH;
+        res[1] = sfrxETH;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == frxETH || token == sfrxETH || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == frxETH || token == sfrxETH;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, frxETH, 18);
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -116,6 +116,8 @@ library Errors {
 
     error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
 
+    error SYBalancerReentrancy();
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/Balancer/IVault.sol

@@ -5,6 +5,21 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "./IAsset.sol";
 
 interface IVault {
+    enum UserBalanceOpKind {
+        DEPOSIT_INTERNAL,
+        WITHDRAW_INTERNAL,
+        TRANSFER_INTERNAL,
+        TRANSFER_EXTERNAL
+    }
+
+    struct UserBalanceOp {
+        UserBalanceOpKind kind;
+        IAsset asset;
+        uint256 amount;
+        address sender;
+        address payable recipient;
+    }
+
     struct JoinPoolRequest {
         address[] assets;
         uint256[] maxAmountsIn;
@@ -61,12 +76,14 @@ interface IVault {
         uint256 deadline
     ) external payable returns (uint256);
 
-    function getPoolTokens(
-        bytes32 poolId
-    )
+    function getPoolTokens(bytes32 poolId)
         external
         view
-        returns (IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
+        returns (
+            IERC20[] memory tokens,
+            uint256[] memory balances,
+            uint256 lastChangeBlock
+        );
 
     function WETH() external view returns (IERC20);
 

package/contracts/interfaces/Frax/IFrxEthMinter.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IFrxEthMinter {
+    function frxETHToken() external view returns (address);
+
+    function sfrxETHToken() external view returns (address);
+
+    function submitAndDeposit(address recipient) external payable returns (uint256 shares);
+}

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

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

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

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

package/deployments/1-markets/BALANCER-LP-AURA-STAFI-RETH-WETH-JUNE-27-2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY Stafi rETH-WETH_BalancerLP Aura",
+    "SY": "0x35BE86140EEC53Da42C265ae764E547df13891c3",
+    "YT": "0xa57FEEDBd31F4ebD7761d5c3aeED7DeCCb8F95eE",
+    "PT": "0x1abfE281466Dc43Ba5e2A7282661735c00BF82DE",
+    "market": "0xB15a55519dBc3D770ddED079ebcDeEea69A49AdE",
+    "expiry": 1719446400,
+    "bulkSeller": "0x6C4aC4B209Cc57B019b83F6771794D3C73BC47Af",
+    "scalarRoot": "25304300000000000000",
+    "initAnchor": "1139984000000000000"
+}

package/deployments/1-markets/SFRXETH-26DEC2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY sfrxETH",
+    "SY": "0xeb83006b0aADdD15AD8AFbebE2f4e0937f210673",
+    "YT": "0x22E250EcaF9090AB3E31916b0411d7c19e085fDE",
+    "PT": "0x6e99277F5349614AE653B8AC9C5e2F105943E8D9",
+    "market": "0xfb8f489df4e04609F4f4e54F586f960818B70041",
+    "expiry": 1735171200,
+    "scalarRoot": "52299600000000000000",
+    "initAnchor": "1124858000000000000"
+}

package/deployments/1-markets/STETH-25DEC2025.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY stETH",
+    "SY": "0xcbC72d92b2dc8187414F6734718563898740C0BC",
+    "YT": "0xf3aBC972A0f537c1119C990d422463b93227Cd83",
+    "PT": "0xf99985822fb361117FCf3768D34a6353E6022F5F",
+    "market": "0xC374f7eC85F8C7DE3207a10bB1978bA104bdA3B2",
+    "expiry": 1766620800,
+    "scalarRoot": "53188170000000000000",
+    "initAnchor": "1168079000000000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.6.0-mainnet",
+  "version": "2.8.0-mainnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,9 +25,9 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.13.0",
+    "hardhat": "^2.13.1",
     "hardhat-contract-sizer": "^2.8.0",
-    "prettier": "^2.8.5",
+    "prettier": "^2.8.7",
     "prettier-plugin-solidity": "^1.1.3",
     "solc": "^0.8.19",
     "solhint": "^3.4.1",