@pendle/core-v2 4.5.1 → 4.6.0

package/contracts/router/ActionMiscV3.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
 import "../interfaces/IPActionMiscV3.sol";
+import "../interfaces/IPReflector.sol";
 
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     function mintSyFromToken(
@@ -79,18 +80,16 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         address[] calldata yts,
         address[] calldata markets
     ) external {
-        unchecked {
-            for (uint256 i = 0; i < sys.length; ++i) {
-                IStandardizedYield(sys[i]).claimRewards(user);
-            }
+        for (uint256 i = 0; i < sys.length; ++i) {
+            IStandardizedYield(sys[i]).claimRewards(user);
+        }
 
-            for (uint256 i = 0; i < yts.length; ++i) {
-                IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
-            }
+        for (uint256 i = 0; i < yts.length; ++i) {
+            IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
+        }
 
-            for (uint256 i = 0; i < markets.length; ++i) {
-                IPMarket(markets[i]).redeemRewards(user);
-            }
+        for (uint256 i = 0; i < markets.length; ++i) {
+            IPMarket(markets[i]).redeemRewards(user);
         }
     }
 
@@ -118,45 +117,194 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPreExpToToken(
+        address receiver,
+        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);
+    }
+
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPreExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) 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 _exitPreExpToSy(
+        bool setReceiverToSy,
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        LimitOrderData calldata limit
+    ) 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;
+    }
+
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPostExpToToken(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output
+    ) external returns (uint256 totalTokenOut, ExitPostExpReturnParams memory params) {
+        IStandardizedYield SY;
+
+        (SY, params) = _exitPostExpToSy(true, address(0), market, netPtIn, netLpIn);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
+
+        emit ExitPostExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
+    }
+
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        uint256 minSyOut
+    ) external returns (ExitPostExpReturnParams memory params) {
+        (, params) = _exitPostExpToSy(false, receiver, market, netPtIn, netLpIn);
+        require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
+
+        emit ExitPostExpToSy(msg.sender, market, receiver, netLpIn, params);
+    }
+
+    function _exitPostExpToSy(
+        bool setReceiverToSy,
+        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 (setReceiverToSy) receiver = address(SY);
+
+        if (netLpIn > 0) {
+            _transferFrom(IERC20(market), msg.sender, market, netLpIn);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(YT), netLpIn);
+        }
+
+        if (netPtIn > 0) {
+            _transferFrom(PT, msg.sender, address(YT), netPtIn);
+        }
+
+        p.netPtRedeem = p.netPtFromRemove + netPtIn;
+        p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem;
+    }
+
     // ----------------- MISC FUNCTIONS -----------------
 
     function boostMarkets(address[] memory markets) external {
-        for (uint256 i = 0; i < markets.length; ) {
+        for (uint256 i = 0; i < markets.length; i++) {
             IPMarket(markets[i]).transferFrom(msg.sender, markets[i], 0);
-            unchecked {
-                i++;
-            }
         }
     }
 
     function multicall(Call3[] calldata calls) external payable returns (Result[] memory res) {
         uint256 length = calls.length;
         res = new Result[](length);
-        Call3 calldata call;
-        for (uint256 i = 0; i < length; ) {
-            call = calls[i];
-
-            // delegatecall to itself, it turns allowing invoking functions from other actions
-            (bool success, bytes memory result) = address(this).delegatecall(call.callData);
-
-            if (!success && !call.allowFailure) {
-                assembly {
-                    // We use Yul's revert() to bubble up errors from the target contract.
-                    revert(add(32, result), mload(result))
-                }
-            }
-
-            res[i].success = success;
-            res[i].returnData = result;
-
-            unchecked {
-                ++i;
-            }
+        for (uint256 i = 0; i < length; i++) {
+            (bool success, bytes memory result) = _delegateToSelf(calls[i].callData, calls[i].allowFailure);
+            res[i] = Result(success, result);
         }
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function callAndReflect(
+        address payable reflector,
+        bytes calldata selfCall1,
+        bytes calldata selfCall2,
+        bytes calldata reflectCall
+    ) external payable returns (bytes memory selfRes1, bytes memory selfRes2, bytes memory reflectRes) {
+        (, selfRes1) = _delegateToSelf(selfCall1, false);
+        if (selfCall2.length > 0) (, selfRes2) = _delegateToSelf(selfCall2, false);
+        reflectRes = _callToReflector(reflector, reflectCall);
+    }
+
     function simulate(address target, bytes calldata data) external payable {
         (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) {
+        return IPReflector(reflector).reflect(data);
+    }
 }

package/contracts/router/ActionSwapYTV3.sol

@@ -52,51 +52,6 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         emit SwapYtAndSy(msg.sender, market, receiver, netYtOut.Int(), exactSyIn.neg());
     }
 
-    function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
-    }
-
-    function _swapExactSyForYt(
-        address receiver,
-        address market,
-        IStandardizedYield SY,
-        IPYieldToken YT,
-        uint256 exactSyIn,
-        uint256 minYtOut,
-        ApproxParams calldata guessYtOut,
-        LimitOrderData calldata limit
-    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
-        uint256 netSyLeft = exactSyIn;
-        bool doMarketOrder = true;
-
-        if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
-            if (doMarketOrder) {
-                _transferOut(address(SY), address(YT), netSyLeft);
-            }
-        }
-
-        if (doMarketOrder) {
-            (uint256 netYtOutMarket, ) = _readMarket(market).approxSwapExactSyForYt(
-                YT.newIndex(),
-                netSyLeft,
-                block.timestamp,
-                guessYtOut
-            );
-
-            (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
-                address(YT),
-                netYtOutMarket, // exactPtIn = netYtOut
-                _encodeSwapExactSyForYt(receiver, YT)
-            );
-
-            netYtOut += netYtOutMarket;
-            netSyFee += netSyFeeMarket;
-        }
-
-        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
-    }
-
     // ------------------ SWAP TOKEN FOR TOKEN ------------------
 
     function swapExactYtForToken(
@@ -138,46 +93,6 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         emit SwapYtAndSy(msg.sender, market, receiver, exactYtIn.neg(), netSyOut.Int());
     }
 
-    function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
-    }
-
-    function _swapExactYtForSy(
-        address receiver,
-        address market,
-        IStandardizedYield SY,
-        IPYieldToken YT,
-        uint256 exactYtIn,
-        uint256 minSyOut,
-        LimitOrderData calldata limit
-    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        uint256 netYtLeft = exactYtIn;
-        bool doMarketOrder = true;
-
-        if (!_isEmptyLimit(limit)) {
-            (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
-            if (doMarketOrder) {
-                _transferOut(address(YT), address(YT), netYtLeft);
-            }
-        }
-
-        if (doMarketOrder) {
-            uint256 preSyBalance = SY.balanceOf(receiver);
-
-            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
-                address(YT),
-                netYtLeft, // exactPtOut = netYtLeft
-                _encodeSwapYtForSy(receiver, YT)
-            );
-
-            // avoid stack issue
-            netSyFee += netSyFeeMarket;
-            netSyOut += SY.balanceOf(receiver) - preSyBalance;
-        }
-
-        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
-    }
-
     // ------------------ SWAP PT FOR YT ------------------
 
     function swapExactPtForYt(

package/contracts/router/Reflector.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPAllActionV3.sol";
+import "../interfaces/IPReflector.sol";
+import "../core/libraries/TokenHelper.sol";
+
+contract Reflector is TokenHelper, IPReflector {
+    using SafeERC20 for IERC20;
+
+    mapping(address => bool) internal approved;
+    address internal constant ROUTER = 0x888888888889758F76e7103c6CbF23ABbF58F946;
+
+    receive() external payable {}
+
+    function reflect(bytes calldata inputData) external returns (bytes memory result) {
+        (uint256 value, bytes memory newCalldata) = _getNewCalldata(inputData);
+        bool success;
+
+        (success, result) = ROUTER.call{value: value}(newCalldata);
+        if (!success) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
+
+    function _getNewCalldata(bytes calldata inputData) internal returns (uint256 value, bytes memory newCalldata) {
+        bytes4 selector = bytes4(inputData[:4]);
+        bytes calldata data = inputData[4:];
+
+        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 = _scaleTokenInputAndGetValue(v5);
+            newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5, v6);
+        } 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 = _scaleTokenInputAndGetValue(v5);
+            newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5);
+        } else {
+            revert("UNSUPPORTED_SELECTOR");
+        }
+    }
+
+    function _scaleTokenInputAndGetValue(TokenInput memory inp) internal returns (uint256 ethValue) {
+        require(inp.swapData.swapType == SwapType.NONE, "SWAP_NOT_ALLOWED"); // the exit call should already swap
+
+        inp.netTokenIn = _selfBalance(inp.tokenIn);
+
+        if (inp.tokenIn == NATIVE) {
+            ethValue = inp.netTokenIn;
+        } else if (!approved[inp.tokenIn]) {
+            IERC20(inp.tokenIn).forceApprove(ROUTER, type(uint256).max);
+            approved[inp.tokenIn] = true;
+        }
+    }
+}

package/contracts/router/base/ActionBase.sol

@@ -10,8 +10,10 @@ import "../../router/base/MarketApproxLib.sol";
 
 import "../../core/libraries/Errors.sol";
 import "../swap-aggregator/IPSwapAggregator.sol";
+import "./CallbackHelper.sol";
 
-abstract contract ActionBase is TokenHelper, IPLimitOrderType {
+abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
+    using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
     using PMath for uint256;
     using PYIndexLib for IPYieldToken;
@@ -236,6 +238,93 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
         if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
     }
 
+    // ----------------- YT SWAP -----------------
+
+    function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : address(YT);
+    }
+
+    function _swapExactYtForSy(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 exactYtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
+        uint256 netYtLeft = exactYtIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(YT), address(YT), netYtLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            uint256 preSyBalance = SY.balanceOf(receiver);
+
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
+                address(YT),
+                netYtLeft, // exactPtOut = netYtLeft
+                _encodeSwapYtForSy(receiver, YT)
+            );
+
+            // avoid stack issue
+            netSyFee += netSyFeeMarket;
+            netSyOut += SY.balanceOf(receiver) - preSyBalance;
+        }
+
+        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
+    }
+
+    function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : address(YT);
+    }
+
+    function _swapExactSyForYt(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 exactSyIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessYtOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
+        uint256 netSyLeft = exactSyIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(SY), address(YT), netSyLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            (uint256 netYtOutMarket, ) = _readMarket(market).approxSwapExactSyForYt(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessYtOut
+            );
+
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+                address(YT),
+                netYtOutMarket, // exactPtIn = netYtOut
+                _encodeSwapExactSyForYt(receiver, YT)
+            );
+
+            netYtOut += netYtOutMarket;
+            netSyFee += netSyFeeMarket;
+        }
+
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
     // ----------------- LIMIT ORDERS -----------------
     function _fillLimit(
         address receiver,

package/deployments/1-core.json

@@ -21,6 +21,14 @@
     "yieldContractFactory": "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD",
     "marketFactory": "0x27b1dAcd74688aF24a64BD3C9C1B143118740784",
     "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
+    "routerFacets": {
+        "ActionAddRemoveLiqV3": "0xb7631b93189900745Db51d960Ba64b8E6C658843",
+        "ActionSwapPTV3": "0xbFA3aAD535e1b996396698f89FFeC7ada0df17E8",
+        "ActionSwapYTV3": "0x8903dBFFcA66b3Fbc027aC81912ea64Fa61A5219",
+        "ActionMiscV3": "0x9afd337e41f59e5c2e6f2be05f32e958a4dbcd9a",
+        "ActionCallbackV3": "0x997FBC511a8Ad11F84a400feACD66E2A3fa805d2",
+        "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
+    },
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
     "pendleSwap": "0x1e8b6Ac39f8A33f46a6Eb2D1aCD1047B99180AD1",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
@@ -35,5 +43,6 @@
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
     "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
-    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9"
+    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9",
+    "reflector": "0x5a04b737D770Ed478cb9b65D1864c24d2E9Ca227"
 }

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

@@ -0,0 +1,14 @@
+{
+    "name": "SY Karak sUSDe",
+    "SY": "0x1b641894e66aec7bf5ab86517e8d81763cc8e19e",
+    "YT": "0xdd68f5D26Bf1182d6b241108bfC01f95C030502b",
+    "PT": "0xd351de53277c4218CC29f793263FB60E2fcFC1dC",
+    "market": "0xB1f587B354a4a363f5332e88effbbC2E4961250A",
+    "expiry": 1727308800,
+    "scalarRoot": "3480095243000000000",
+    "initAnchor": "1243231806000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0xb133757035e5f335a6070099cca7dfc7f34b3d2078cb3929db627a5e5228f50b",
+    "deployBlockNumber": 19967918,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/1-markets/KARAK-USDE-MAINNET-SEP2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY Karak USDe",
+    "SY": "0xfe2d379117895fa6144b209c13894a17ab18c86c",
+    "YT": "0x2e40D7Cfee1e7D31d1F4875e6F33B2c9a17038fF",
+    "PT": "0x791c1E9D38029092E8aD1E252d0Bb97261809A2c",
+    "market": "0x1BCBDB8c8652345A5ACF04e6E74f70086c68FEfC",
+    "expiry": 1727308800,
+    "scalarRoot": "3070185566000000000",
+    "initAnchor": "1247051504000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0xa74e87ad2f48154eb1192498122c80d99c11c2938cc2fd8bf3d6330132e9f520",
+    "deployBlockNumber": 19967899,
+    "reversedFee": 0.2999999999199199
+}

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

@@ -0,0 +1,14 @@
+{
+    "name": "SY Karak eETH",
+    "SY": "0x8db42af6b2de9e8aee47f3423570d8e9c3873796",
+    "YT": "0x5439c3Ef0072e4A19C44478CDF947F5d957e66C7",
+    "PT": "0x5E9e4bFd81c8c03F8289b827C9B92332789b6fe1",
+    "market": "0x18bAFcaBf2d5898956AE6AC31543d9657a604165",
+    "expiry": 1727308800,
+    "scalarRoot": "3612434850000000000",
+    "initAnchor": "1216826907000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0x26bba852c4385f67503265fb85d16df41325aeec85668cea7a8b062d7d1fbe7a",
+    "deployBlockNumber": 19967933,
+    "reversedFee": 0.2999999999199199
+}

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/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-offchain-helper.json

@@ -2,5 +2,6 @@
     "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
     "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C",
     "implicitSwapfeeContract": "0x43D03031FAb845065e9CEfE89Dd122d63F72011F",
-    "simulateHelper": "0x2b3EC64160F658fFe7061769415Ff080fca80BbA"
+    "simulateHelper": "0x2b3EC64160F658fFe7061769415Ff080fca80BbA",
+    "supplyCapReader": "0x438C7dBA7d355aA0c77459AF38B2E62f9f9EccBf"
 }