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

package/contracts/router/ActionMiscV3.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
 import "../interfaces/IPActionMiscV3.sol";
+import "./Reflector.sol";
 
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     function mintSyFromToken(
@@ -116,206 +117,149 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
-    event ExitMultiplePreExpiry(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netLpToRemove,
-        uint256 netPtFromRemove,
-        uint256 netSyFromRemove,
-        uint256 netPyRedeem,
-        uint256 netSyFromRedeem,
-        uint256 netPtSwap,
-        uint256 netYtSwap,
-        uint256 netSyFromSwap,
-        uint256 netSyFee,
-        uint256 netTokenOut
-    );
-
-    event ExitMultiplePostExpiry(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
+    // double check event orders
+
+    function exitPreExpToToken(
         address receiver,
-        uint256 netLpToRemove,
-        uint256 netPtFromRemove, //
-        uint256 netSyFromRemove, //
-        uint256 netPtRedeem,
-        uint256 netSyFromRedeem, //
-        uint256 netTokenOut //
-    );
-
-    // TODO: need to allow exit to SY as well
-
-    struct ExitMultipleParams {
-        address receiver;
-        address market;
-        uint256 netPtIn;
-        uint256 netYtIn;
-        uint256 netLpIn;
-        TokenOutput output;
-        LimitOrderData limit;
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 totalTokenOut, ExitPreExpReturnParams memory params) {
+        IStandardizedYield SY;
+
+        (SY, params) = _exitPreExpToSy(true, address(0), market, netPtIn, netYtIn, netLpIn, limit);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
+
+        emit ExitPreExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
     }
 
-    function exitMultiplePreExpiry(
+    function exitPreExpToSy(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netYtIn,
         uint256 netLpIn,
-        TokenOutput calldata output,
+        uint256 minSyOut,
         LimitOrderData calldata limit
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPyRedeem,
-            uint256 netSyFromRedeem,
-            uint256 netPtSwap,
-            uint256 netYtSwap,
-            uint256 netSyFromSwap,
-            uint256 netSyFee
-        )
-    {
-        (
-            netTokenOut,
-            netPtFromRemove,
-            netSyFromRemove,
-            netPyRedeem,
-            netSyFromRedeem,
-            netPtSwap,
-            netYtSwap,
-            netSyFromSwap,
-            netSyFee
-        ) = exitMultiplePreExpiryInner(receiver, market, netPtIn, netYtIn, netLpIn, output, limit);
-
-        emit ExitMultiplePreExpiry(
-            msg.sender,
-            market,
-            output.tokenOut,
-            receiver,
-            netLpIn,
-            netPtFromRemove,
-            netSyFromRemove,
-            netPyRedeem,
-            netSyFromRedeem,
-            netPtSwap,
-            netYtSwap,
-            netSyFromSwap,
-            netSyFee,
-            netTokenOut
-        );
+    ) external returns (ExitPreExpReturnParams memory params) {
+        (, params) = _exitPreExpToSy(false, receiver, market, netPtIn, netYtIn, netLpIn, limit);
+        require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
+
+        emit ExitPreExpToSy(msg.sender, market, receiver, netLpIn, params);
     }
 
-    function exitMultiplePreExpiryInner(
+    function _exitPreExpToSy(
+        bool setReceiverToSy,
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netYtIn,
         uint256 netLpIn,
-        TokenOutput calldata output,
         LimitOrderData calldata limit
-    )
-        internal
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPyRedeem,
-            uint256 netSyFromRedeem,
-            uint256 netPtSwap,
-            uint256 netYtSwap,
-            uint256 netSyFromSwap,
-            uint256 netSyFee
-        )
-    {
-        // (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-        // if (netLpIn > 0) {
-        //     _transferFrom(IERC20(market), msg.sender, market, netLpIn);
-        //     (netSyFromRemove, netPtFromRemove) = IPMarket(market).burn(address(SY), address(this), netLpIn);
-        // }
-        // if (netPtIn > 0) {
-        //     _transferIn(address(PT), address(this), netPtIn);
-        // }
-        // netPyRedeem = PMath.min(netPtFromRemove + netPtIn, netYtIn);
-        // if (netPyRedeem > 0) {
-        //     _transferOut(address(PT), address(YT), netPyRedeem);
-        //     _transferFrom(YT, msg.sender, address(YT), netPyRedeem);
-        //     netSyFromRedeem = IPYieldToken(YT).redeemPY(address(SY));
-        // }
-        // netPtSwap = netPtFromRemove + netPtIn - netPyRedeem;
-        // netYtSwap = netYtIn - netPyRedeem;
-        // if (netPtSwap > 0) {
-        //     address ptEntry = _entry_swapExactPtForSy(market, limit);
-        //     if (ptEntry != address(this)) _transferOut(address(PT), ptEntry, netPtSwap);
-        //     (netSyFromSwap, netSyFee) = _swapExactPtForSy(address(SY), market, netPtSwap, 0, limit);
-        // } else if (netYtSwap > 0) {
-        //     _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), netYtSwap);
-        //     (netSyFromSwap, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, netYtSwap, 0, limit);
-        // }
-        // uint256 netSyRedeem = netSyFromRemove + netSyFromRedeem + netSyFromSwap;
-        // netTokenOut = _redeemSyToToken(receiver, address(SY), netSyRedeem, output, false);
+    ) internal returns (IStandardizedYield SY, ExitPreExpReturnParams memory p) {
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+        (SY, PT, YT) = IPMarket(market).readTokens();
+
+        if (setReceiverToSy) receiver = address(SY);
+
+        if (netLpIn > 0) {
+            _transferFrom(IERC20(market), msg.sender, market, netLpIn);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(this), netLpIn);
+        }
+
+        if (netPtIn > 0) {
+            _transferIn(address(PT), msg.sender, netPtIn);
+        }
+
+        p.netPyRedeem = PMath.min(p.netPtFromRemove + netPtIn, netYtIn);
+
+        if (p.netPyRedeem > 0) {
+            _transferOut(address(PT), address(YT), p.netPyRedeem);
+            _transferFrom(YT, msg.sender, address(YT), p.netPyRedeem);
+            p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+        }
+
+        p.netPtSwap = p.netPtFromRemove + netPtIn - p.netPyRedeem;
+        p.netYtSwap = netYtIn - p.netPyRedeem;
+
+        if (p.netPtSwap > 0) {
+            address ptEntry = _entry_swapExactPtForSy(market, limit);
+            if (ptEntry != address(this)) _transferOut(address(PT), ptEntry, p.netPtSwap);
+            (p.netSyFromSwap, p.netSyFee) = _swapExactPtForSy(receiver, market, p.netPtSwap, 0, limit);
+        } else if (p.netYtSwap > 0) {
+            _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), p.netYtSwap);
+            (p.netSyFromSwap, p.netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, p.netYtSwap, 0, limit);
+        }
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem + p.netSyFromSwap;
     }
 
-    // TODO: is netSyInterm necessary? can we return more?
-    // TODO: compare interface against existing functions, to see if it makes sense
-    function exitMultiplePostExpiry(
+    function exitPostExpToToken(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netLpIn,
         TokenOutput calldata output
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPtRedeem,
-            uint256 netSyFromRedeem
-        )
-    {
-        // * (done) maybe shouldn't reuse functions because of conflicting events
-        // * (KIV) expose all inner workings variables
-        // also: should match events with existing events
-        // events, no matter what is emitted, can be parsed dynamically on BE. Say if only PT is exited, it can be parsed
-        // as swapExact
-
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-
-        // uint256 netPtFromRemove;
-        // uint256 netSyFromRemove;
+    ) external returns (uint256 totalTokenOut, ExitPostExpReturnParams memory params) {
+        IStandardizedYield SY;
+
+        (SY, params) = _exitPostExpToSy(receiver, market, netPtIn, netLpIn);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
+
+        emit ExitPostExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
+    }
+
+    function exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        uint256 minSyOut
+    ) external returns (ExitPostExpReturnParams memory params) {
+        (, params) = _exitPostExpToSy(receiver, market, netPtIn, netLpIn);
+        require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
+
+        emit ExitPostExpToSy(msg.sender, market, receiver, netLpIn, params);
+    }
+
+    function _exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn
+    ) internal returns (IStandardizedYield SY, ExitPostExpReturnParams memory p) {
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+        (SY, PT, YT) = IPMarket(market).readTokens();
 
         if (netLpIn > 0) {
             _transferFrom(IERC20(market), msg.sender, market, netLpIn);
-            (netSyFromRemove, netPtFromRemove) = IPMarket(market).burn(address(SY), address(YT), netLpIn);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(YT), netLpIn);
         }
 
         if (netPtIn > 0) {
             _transferFrom(PT, msg.sender, address(YT), netPtIn);
         }
 
-        netPtRedeem = netPtFromRemove + netPtIn;
-        netSyFromRedeem = IPYieldToken(YT).redeemPY(address(SY));
-
-        uint256 netSyRedeem = netSyFromRemove + netSyFromRedeem;
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyRedeem, output, false);
-
-        emit ExitMultiplePostExpiry(
-            msg.sender,
-            market,
-            output.tokenOut,
-            receiver,
-            netLpIn,
-            netPtFromRemove,
-            netSyFromRemove,
-            netPtRedeem,
-            netSyFromRedeem,
-            netTokenOut
-        );
+        p.netPtRedeem = p.netPtFromRemove + netPtIn;
+        p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem;
+    }
+
+    function multicallAlpha(
+        address payable reflector,
+        bytes calldata selfCall,
+        bytes calldata reflectCall
+    ) external payable returns (bytes memory selfRes, bytes memory reflectRes) {
+        (, selfRes) = _delegateToSelf(selfCall, false);
+        reflectRes = _callToReflector(reflector, reflectCall);
+
+        // ? We don't need to check balance here, can trust SDK?
     }
 
     // ----------------- MISC FUNCTIONS -----------------
@@ -339,4 +283,33 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         (bool success, bytes memory result) = target.delegatecall(data);
         revert Errors.SimulationResults(success, result);
     }
+
+    function _delegateToSelf(
+        bytes memory data,
+        bool allowFailure
+    ) internal returns (bool success, bytes memory result) {
+        (success, result) = address(this).delegatecall(data);
+
+        if (!success && !allowFailure) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
+
+    function _callToReflector(address payable reflector, bytes memory data) internal returns (bytes memory result) {
+        // TODO: should we allow arbitrary passing?
+        // TODO: is the payable necessary?
+
+        bool success;
+        (success, result) = Reflector(reflector).reflect(data);
+
+        if (!success) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
 }

package/contracts/router/Reflector.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPAllActionV3.sol";
+import "../core/libraries/TokenHelper.sol";
+
+contract Reflector is TokenHelper {
+    using SafeERC20 for IERC20;
+
+    mapping(address => bool) internal approved;
+
+    receive() external payable {}
+
+    function reflect(bytes calldata inputData) external returns (bool success, bytes memory result) {
+        (uint256 value, bytes memory newCalldata) = _process1(inputData);
+        (success, result) = msg.sender.call{value: value}(newCalldata);
+    }
+
+    function _process1(bytes calldata inputData) internal returns (uint256 value, bytes memory newCalldata) {
+        bytes4 selector = bytes4(inputData[:4]);
+        bytes calldata data = inputData[4:];
+
+        // TODO: can we do nicer here?
+        if (selector == IPActionAddRemoveLiqV3.addLiquiditySingleToken.selector) {
+            (
+                address v1,
+                address v2,
+                uint256 v3,
+                ApproxParams memory v4,
+                TokenInput memory v5,
+                LimitOrderData memory v6
+            ) = abi.decode(data, (address, address, uint256, ApproxParams, TokenInput, LimitOrderData));
+
+            value = _process2(v5);
+            newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5, v6);
+            _safeApproveInf(v5.tokenIn, msg.sender);
+        } else if (selector == IPActionAddRemoveLiqV3.addLiquiditySingleTokenKeepYt.selector) {
+            (address v1, address v2, uint256 v3, uint256 v4, TokenInput memory v5) = abi.decode(
+                data,
+                (address, address, uint256, uint256, TokenInput)
+            );
+
+            value = _process2(v5);
+            newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5);
+        } else {
+            revert("UNSUPPORTED_SELECTOR");
+        }
+    }
+
+    function _process2(TokenInput memory inp) internal returns (uint256 ethValue) {
+        assert(inp.swapData.swapType == SwapType.NONE);
+
+        inp.netTokenIn = _selfBalance(inp.tokenIn);
+        ethValue = inp.tokenIn == NATIVE ? inp.netTokenIn : 0;
+
+        if (inp.tokenIn != NATIVE && !approved[inp.tokenIn]) {
+            IERC20(inp.tokenIn).safeApprove(msg.sender, type(uint256).max);
+            approved[inp.tokenIn] = true;
+        }
+    }
+}

package/contracts/router/base/ActionBase.sol

@@ -373,20 +373,4 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
         return a.normalFills.length == 0 && a.flashFills.length == 0;
     }
-
-    // ----------------- DELEGATE CALL -----------------
-
-    function _delegateToSelf(
-        bytes memory data,
-        bool allowFailure
-    ) internal returns (bool success, bytes memory result) {
-        (success, result) = address(this).delegatecall(data);
-
-        if (!success && !allowFailure) {
-            assembly {
-                // We use Yul's revert() to bubble up errors from the target contract.
-                revert(add(32, result), mload(result))
-            }
-        }
-    }
 }

package/deployments/1-markets/EZETH-MAINNET-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY ezETH",
+    "SY": "0x22E12A50e3ca49FB183074235cB1db84Fe4C716D",
+    "YT": "0x1623F1A991584A6b69baBbdbffD26E2B46485465",
+    "PT": "0x248241244356D18f63d0c16082996839ecB0C7bF",
+    "market": "0xcDBD5ff3E03b6828Db9C32e2131A60ABA5137901",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/PUFETH-MAINNET-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY pufETH",
+    "SY": "0x253008ba4aE2f3E6488DC998a5321D4EB1a0c905",
+    "YT": "0x1a65eB80a2ac3ea6E41D456DdD6E9cC5728BEf7C",
+    "PT": "0xd4e75971eAF78a8d93D96df530f1FFf5f9F53288",
+    "market": "0xA54FC268101c8b97DE19eF3141d34751a11996B2",
+    "expiry": 1727308800,
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/RSETH-MAINNET-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rsETH",
+    "SY": "0x730A5E2AcEbccAA5e9095723B3CB862739DA793c",
+    "YT": "0xE653E4048620E546AFff02D3689678896d22e236",
+    "PT": "0x7bAf258049cc8B9A78097723dc19a8b103D4098F",
+    "market": "0x6b4740722e46048874d84306B2877600ABCea3Ae",
+    "expiry": 1727308800,
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/RSWETH-SWELL-STAKING-MAINNET-JUL2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rswETH",
+    "SY": "0x4f3A7a07A968B67F1f9692b70242f10E665d38Ad",
+    "YT": "0xf0E4244Ca93Ac36752DA5939Afd9CB73B0637b06",
+    "PT": "0x0a0E172511114456EC63A85FF32E45C5e0E27D63",
+    "market": "0x1e0c2e41f3165ff6B8a660092f63E10BC0EebE26",
+    "expiry": 1721865600,
+    "scalarRoot": "8113474588000000000",
+    "initAnchor": "1061316437000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/1-markets/SUSDE-MAINNET-SEP2024.json

@@ -0,0 +1,13 @@
+{
+    "name": "SUSDE-MAINNET-SEP2024",
+    "SY": "0x4139cDC6345aFFbaC0692b43bed4D059Df3e6d65",
+    "YT": "0xdc02b77a3986da62C7A78FED73949C9767850809",
+    "PT": "0x6c9f097e044506712B58EAC670c9a5fd4BCceF13",
+    "market": "0xd1D7D99764f8a52Aff007b7831cc02748b2013b5",
+    "expiry": 1727308800,
+    "lnFeeRateRoot": "2995508979000000",
+    "scalarRoot": "8580934398000000000",
+    "initAnchor": "1120006408000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0x467c0c15148778d0b99a1d9f3bd7406fd0c58d8a6e3284a57a50e55ae0160165"
+}

package/deployments/1-markets/UNIETH-MAINNET-SEP2024.json

@@ -0,0 +1,13 @@
+{
+    "name": "UNIETH-MAINNET-SEP2024",
+    "SY": "0xc430dB19339A3051192233B4c49f9aB3DC6D16b7",
+    "YT": "0xdF74bA4436478969A54eCB352093312fE97EBAa5",
+    "PT": "0x15fA86404BFbA8b46684552F792558128bFB6418",
+    "market": "0xBaE2Df4DfCd0c613018D6056A40077F2d1eFf28A",
+    "expiry": 1727308800,
+    "lnFeeRateRoot": "2995508979000000",
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0x4e509feb8502bee0c719c1a9eb2c73c9e1b070fc8424e1f4f31618bdc764a560"
+}

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

@@ -0,0 +1,11 @@
+{
+    "name": "SY weETH",
+    "SY": "0xAC0047886a985071476a1186bE89222659970d65",
+    "YT": "0xA54Df645A042D24121a737dAA89a57EbF8E0b71c",
+    "PT": "0x1c085195437738d73d75DC64bC5A3E098b7f93b1",
+    "market": "0xC8eDd52D0502Aa8b4D5C77361D4B3D300e8fC81c",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/42161-core.json

@@ -19,7 +19,7 @@
     "PENDLE": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
     "yieldContractFactory": "0x28dE02Ac3c3F5ef427e55c321F73fDc7F192e8E4",
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
-    "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
+    "router": "0xaBbCC1E99687b2d5B6db8bC5dD8904B142Eaf04b",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
     "pendleSwap": "0x63a45E0B2686F7be77Bb85735c35704D1046459a",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",

package/deployments/42161-markets/EZETH-ARB-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY ezETH",
+    "SY": "0x0dE802e3D6Cc9145A150bBDc8da9F988a98c5202",
+    "YT": "0xE58AfaA6E2abF9A9F243D5A55Bd5447628c4D811",
+    "PT": "0x2CCFce9bE49465CC6f947b5F6aC9383673733Da9",
+    "market": "0x35f3dB08a6e9cB4391348b0B404F493E7ae264c0",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/42161-markets/RSETH-ARBITRUM-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rsETH",
+    "SY": "0xf176fB51F4eB826136a54FDc71C50fCd2202E272",
+    "YT": "0x2FDc424946AA72D42E2F897447d7c335E64845F0",
+    "PT": "0x30c98c0139B62290E26aC2a2158AC341Dcaf1333",
+    "market": "0x1d38d4204159aA5e767aFbA8f76BE22117De61E5",
+    "expiry": 1727308800,
+    "scalarRoot": "7770558179000000000",
+    "initAnchor": "1110275954000000000",
+    "lnFeeRateRoot": "29999550000000"
+}

package/deployments/42161-markets/SILO-PTEETH-ARBITRUM-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY sETH-pteETHSilo",
+    "SY": "0xd0c4351a18F40b96b6446Da3A191496DF36d60F9",
+    "YT": "0x7Cfb81E9c9402D48c6F3161204a21800b210BAeA",
+    "PT": "0x2D5405688f253D741a9F1090DD90D8A285CF5C79",
+    "market": "0x6aBE9Ac2df48490693BdB9d66Fa898fc9cD7cc36",
+    "expiry": 1719446400,
+    "scalarRoot": "10324763686000000000",
+    "initAnchor": "1041846750000000000",
+    "lnFeeRateRoot": "499875041000000"
+}

package/deployments/42161-markets/SILO-PTEZETH-ARBITRUM-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY sETH-ptezETHSilo",
+    "SY": "0x8242F81F7B06C1e67bC80DFD2B2716f58bD46651",
+    "YT": "0x8138E8cAC470Dc963437b055834B54D56d6d6a29",
+    "PT": "0xd7e810aEd2988B8A7eA0187d55C939110b178521",
+    "market": "0xCf602767e9c82194DaF58EB67a3169d60DbAaC62",
+    "expiry": 1719446400,
+    "scalarRoot": "10324763686000000000",
+    "initAnchor": "1041846750000000000",
+    "lnFeeRateRoot": "499875041000000"
+}

package/deployments/42161-markets/WEETH-ARB-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY weETH",
+    "SY": "0xa6C895EB332E91c5b3D00B7baeEAae478cc502DA",
+    "YT": "0xfB2A7AC0372C2425c273932f8d438518402A873E",
+    "PT": "0xb8b0a120F6A68Dd06209619F62429fB1a8e92feC",
+    "market": "0xf9F9779d8fF604732EBA9AD345E6A27EF5c2a9d6",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/deployments/56-markets/WEETH-BSC-SEP2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY weETH",
+    "SY": "0x56b70AC3a6Ae850F6AEE67591d1bB86895Ba211E",
+    "YT": "0xBf1E6E67cE2Bd8da1ea7342354126b59B46d4000",
+    "PT": "0x0E8Ba474FCB6581059C61c328a21CFa285C7Cee7",
+    "market": "0x27255F9aFF1868A8eFB1182471F4De2121946Fd0",
+    "expiry": 1727308800,
+    "scalarRoot": "7728447732000000000",
+    "initAnchor": "1116672357000000000",
+    "lnFeeRateRoot": "2995508979000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "4.5.1-beta-1",
+  "version": "4.5.1-beta-3",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -49,4 +49,4 @@
     "@openzeppelin/contracts": "4.9.3",
     "@openzeppelin/contracts-upgradeable": "4.9.3"
   }
-}
+}