@pendle/core-v2 6.5.0 → 6.6.1

package/contracts/limit/LimitRouterBase.sol

@@ -4,18 +4,18 @@ pragma solidity ^0.8.17;
 
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IPAllActionV3.sol";
 import "../interfaces/IPLimitRouter.sol";
 import "../interfaces/IStandardizedYield.sol";
-import "../interfaces/IWETH.sol";
 import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
+import "./helpers/MintSyHelper.sol";
 import "./helpers/NonceManager.sol";
-import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
 import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 
 abstract contract LimitRouterBase is
-    EIP712Upgradeable,
     IPLimitRouter,
     BoringOwnableUpgradeableV2,
+    MintSyHelper,
     NonceManager,
     TokenHelper
 {
@@ -28,31 +28,28 @@ abstract contract LimitRouterBase is
 
     uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
     uint128 internal constant _ORDER_FILLED = 1;
-    uint256 internal constant NEW_PRIME = 12_421;
     uint256 internal constant MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
 
-    bytes private constant EMPTY_BYTES = abi.encode();
-
     address public feeRecipient;
 
     // YT => lnFeeRateRoot // not to be accessed directly
     mapping(address => uint256) internal __lnFeeRateRoot;
 
     address public immutable WNATIVE;
+    address public immutable ROUTER;
 
     mapping(bytes32 => OrderStatus) internal _status;
 
-    address public ownerHelper;
+    address private __deprecated__ownerHelper;
 
-    uint256[99] private __gap;
+    address public mintSySigner1;
+    address public mintSySigner2;
 
-    modifier onlyHelperAndOwner() {
-        require(msg.sender == ownerHelper || msg.sender == owner, "not allowed");
-        _;
-    }
+    uint256[97] private __gap;
 
-    constructor(address _WNATIVE) {
+    constructor(address _WNATIVE, address _ROUTER) {
         WNATIVE = _WNATIVE;
+        ROUTER = _ROUTER;
     }
 
     // solhint-disable-next-line no-empty-blocks
@@ -69,18 +66,20 @@ abstract contract LimitRouterBase is
         FillOrderParams[] memory params,
         address receiver,
         uint256 maxTaking,
-        bytes calldata,
-        /*optData*/
+        bytes memory optData,
         bytes memory callback
     ) external returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
-        params = _validateSkipSigAndFilterOrders(params);
+        OptionalArgs memory oArgs = _decodeAndVerifySigOpt_prePrune(params, optData);
+
+        _validateSkipSigAndPruneOrders(params);
         if (params.length == 0) return fillNoOrders(callback);
 
         OrderType orderType = params[0].order.orderType;
+        Args memory a = Args(orderType, params, receiver, maxTaking, callback, oArgs);
         if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return fillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
+            return fillTokenForPY(a);
         } else {
-            return fillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
+            return fillPYForToken(a);
         }
     }
 
@@ -92,6 +91,11 @@ abstract contract LimitRouterBase is
         address receiver;
         uint256 maxTaking;
         bytes callback;
+        OptionalArgs oArgs;
+    }
+
+    struct OptionalArgs {
+        MintSyData mintSyData;
     }
 
     function fillNoOrders(bytes memory callback)
@@ -109,7 +113,7 @@ abstract contract LimitRouterBase is
         (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndStatus(a.params);
 
         // Token => This
-        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
+        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params, a.oArgs.mintSyData);
 
         FillResults memory out = LimitMath.calcBatch(a.params, YT, getLnFeeRateRoot(YT));
         (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
@@ -165,35 +169,43 @@ abstract contract LimitRouterBase is
     }
 
     // ----------------- verify & convert functions -----------------
-    function _validateSkipSigAndFilterOrders(FillOrderParams[] memory params)
+
+    function _decodeAndVerifySigOpt_prePrune(FillOrderParams[] memory params, bytes memory optData)
         internal
         view
-        returns (FillOrderParams[] memory res)
+        returns (OptionalArgs memory oArgs)
     {
+        if (optData.length != 0) {
+            (uint256 version, bytes memory payload) = abi.decode(optData, (uint256, bytes));
+            require(version == 1, "LOP: invalid version");
+
+            oArgs.mintSyData = abi.decode(payload, (MintSyData));
+            _verifyMintSyData(oArgs.mintSyData, hashFillParams(params), mintSySigner1, mintSySigner2);
+        }
+    }
+
+    function _validateSkipSigAndPruneOrders(FillOrderParams[] memory params) internal view {
         uint256 len = params.length;
         require(len != 0, "LOP: empty batch");
 
         (address YT, OrderType orderType) = (params[0].order.YT, params[0].order.orderType);
         require(block.timestamp < IPYieldToken(YT).expiry(), "LOP: PY expired");
 
-        uint256 skipped = 0;
+        uint256 keep = 0;
         for (uint256 i = 0; i < len; i++) {
             Order memory order = params[i].order;
+
+            require(i == 0 || order.token >= params[i - 1].order.token, "LOP: invalid ordering");
             require(order.orderType == orderType && order.YT == YT, "LOP: mismatch types");
 
-            if (!(block.timestamp < order.expiry && order.nonce >= nonce[order.maker])) {
-                skipped++;
-                params[i].signature = EMPTY_BYTES;
-            }
+            if (!(block.timestamp < order.expiry && order.nonce >= nonce[order.maker])) continue;
+
+            params[keep] = params[i];
+            keep++;
         }
 
-        res = new FillOrderParams[](len - skipped);
-        uint256 iter = 0;
-        for (uint256 i = 0; i < len; i++) {
-            if (params[i].signature.length != 0) {
-                res[iter] = params[i];
-                iter++;
-            }
+        assembly ("memory-safe") {
+            mstore(params, keep)
         }
     }
 
@@ -294,12 +306,13 @@ abstract contract LimitRouterBase is
         return (orderHash, remainingMakerAmount, filledMakerAmount);
     }
 
-    // ----------------- simple helper functions functions -----------------
+    // ----------------- simple helper functions -----------------
 
-    function _transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
-        internal
-        returns (uint256[] memory fromMakers)
-    {
+    function _transferFromMakers_mintSy_updMakings(
+        address SY,
+        FillOrderParams[] memory params,
+        MintSyData memory mintSyData
+    ) internal returns (uint256[] memory fromMakers) {
         uint256 len = params.length;
         fromMakers = new uint256[](len);
 
@@ -314,21 +327,54 @@ abstract contract LimitRouterBase is
 
             if (sharedToken == SY || totalMaking == 0) continue;
 
-            uint256 totalSy = __mintSy_Single(SY, sharedToken, totalMaking);
+            uint256 totalSy = __mintSy_Single(SY, sharedToken, totalMaking, mintSyData.inps, mintSyData.minSyOuts);
             for (uint256 i = l; i < r; i++) {
                 uint256 netToken = params[i].makingAmount;
                 uint256 netSy = (netToken * totalSy) / totalMaking;
-
-                if (_isNewOrder(params[i].order)) {
-                    require(netToken.mulDown(params[i].order.failSafeRate) <= netSy, "LOP: fail safe");
-                }
+                require(netToken.mulDown(params[i].order.failSafeRate) <= netSy, "LOP: fail safe");
 
                 params[i].makingAmount = netSy;
             }
         }
     }
 
-    function __mintSy_Single(address SY, address token, uint256 netTokenIn) private returns (uint256 netSyOut) {
+    /// @dev each token group appears at most once because params are sorted by token
+    function __mintSy_Single(
+        address SY,
+        address token,
+        uint256 netTokenIn,
+        TokenInput[] memory inps,
+        uint256[] memory minSyOuts
+    ) private returns (uint256 netSyOut) {
+        for (uint256 i = 0; i < inps.length; i++) {
+            if (inps[i].tokenIn == token) {
+                return __mintSy_Single_viaRouter(SY, token, netTokenIn, inps[i], minSyOuts[i]);
+            }
+        }
+        return __mintSy_Single_direct(SY, token, netTokenIn);
+    }
+
+    function __mintSy_Single_viaRouter(
+        address SY,
+        address token,
+        uint256 netTokenIn,
+        TokenInput memory inp,
+        uint256 minSyOut
+    ) private returns (uint256 netSyOut) {
+        require(inp.swapData.needScale, "LOP: need scale");
+        require(netTokenIn <= inp.netTokenIn, "LOP: only scale down");
+
+        // Scale down input
+        uint256 scaledMinSyOut = (minSyOut * netTokenIn) / inp.netTokenIn;
+        require(scaledMinSyOut > 0, "LOP: zero scaledMinSy");
+        inp.netTokenIn = netTokenIn;
+
+        // Approve and mint via router
+        _safeApproveInf(token, ROUTER);
+        netSyOut = IPAllActionV3(ROUTER).mintSyFromToken(address(this), SY, scaledMinSyOut, inp);
+    }
+
+    function __mintSy_Single_direct(address SY, address token, uint256 netTokenIn) private returns (uint256 netSyOut) {
         if (token == WNATIVE && !IStandardizedYield(SY).isValidTokenIn(WNATIVE)) {
             _wrap_unwrap_ETH(WNATIVE, NATIVE, netTokenIn);
             token = NATIVE;
@@ -379,12 +425,9 @@ abstract contract LimitRouterBase is
             }
 
             for (uint256 i = l; i < r; i++) {
-                if (_isNewOrder(params[i].order)) {
-                    uint256 netSy = netSyOuts[i];
-                    uint256 netToken = toMakers[i];
-
-                    require(netSy.mulDown(params[i].order.failSafeRate) <= netToken, "LOP: fail safe");
-                }
+                uint256 netSy = netSyOuts[i];
+                uint256 netToken = toMakers[i];
+                require(netSy.mulDown(params[i].order.failSafeRate) <= netToken, "LOP: fail safe");
             }
         }
     }
@@ -437,8 +480,8 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function _isNewOrder(Order memory order) internal pure returns (bool) {
-        return order.salt % NEW_PRIME == 0;
+    function hashFillParams(FillOrderParams[] memory params) public pure returns (bytes32) {
+        return keccak256(abi.encode(params));
     }
 
     function hashOrder(Order memory order) public view returns (bytes32) {
@@ -460,14 +503,16 @@ abstract contract LimitRouterBase is
         feeRecipient = _feeRecipient;
     }
 
-    function setOwnerHelper(address _helper) public onlyOwner {
-        ownerHelper = _helper;
+    function setMintSySigners(address _signer1, address _signer2) public onlyOwner {
+        mintSySigner1 = _signer1;
+        mintSySigner2 = _signer2;
+        emit MintSySignersSet(_signer1, _signer2);
     }
 
     /// @dev if zero fees are intended, it must be explicitly allowed again
     function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots, bool allowZeroFees)
         public
-        onlyHelperAndOwner
+        onlyOwner
     {
         uint256 len = YTs.length;
         require(len == lnFeeRateRoots.length, "LOP: length mismatch");

package/contracts/limit/PendleLimitRouter.sol

@@ -6,11 +6,33 @@ import "./LimitRouterBase.sol";
 
 contract PendleLimitRouter is LimitRouterBase {
     using Address for address;
+    using PMath for uint256;
 
-    constructor(address _WNATIVE) LimitRouterBase(_WNATIVE) {
+    constructor(address _WNATIVE, address _ROUTER) LimitRouterBase(_WNATIVE, _ROUTER) {
         _disableInitializers();
     }
 
+    /// @notice Pre-sign multiple orders on-chain by setting remaining amount to makingAmount
+    function preSignBatch(Order[] calldata orders) external {
+        for (uint256 i = 0; i < orders.length; ++i) {
+            preSignSingle(orders[i]);
+        }
+    }
+
+    /// @notice Pre-sign order by setting remaining amount to makingAmount
+    /// @dev Allow bypassing EIP-712 signature validation during fill
+    function preSignSingle(Order calldata order) public {
+        require(order.maker == msg.sender, "LOP: Access denied");
+        require(order.nonce >= nonce[order.maker], "LOP: invalid nonce");
+        require(block.timestamp < order.expiry && order.expiry < IPYieldToken(order.YT).expiry(), "LOP: invalid expiry");
+
+        bytes32 orderHash = hashOrder(order);
+        require(_status[orderHash].remaining == _ORDER_DOES_NOT_EXIST, "LOP: already exist");
+        _status[orderHash].remaining = (order.makingAmount + 1).Uint128();
+
+        emit OrderPreSigned(orderHash, order);
+    }
+
     /// @notice Cancels multiple orders by setting remaining amount to zero
     function cancelBatch(Order[] calldata orders) external {
         for (uint256 i = 0; i < orders.length; ++i) {
@@ -30,7 +52,7 @@ contract PendleLimitRouter is LimitRouterBase {
     }
 
     /// @dev auto skip cancelled orders to avoid race conditions
-    function forceCancel(bytes32[] calldata orderHashes) public onlyHelperAndOwner {
+    function forceCancel(bytes32[] calldata orderHashes) public onlyOwner {
         for (uint256 i = 0; i < orderHashes.length; ++i) {
             if (_status[orderHashes[i]].remaining == _ORDER_FILLED) continue;
 

package/contracts/limit/helpers/MintSyHelper.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IPLimitRouter.sol";
+import "../../interfaces/IPAllActionTypeV3.sol";
+import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+
+abstract contract MintSyHelper is EIP712Upgradeable {
+    // forgefmt: disable-next-item
+    bytes32 internal constant SWAP_DATA_TYPEHASH = keccak256(
+        "SwapData("
+            "uint8 swapType,"
+            "address extRouter,"
+            "bytes extCalldata,"
+            "bool needScale"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant TOKEN_INPUT_TYPEHASH = keccak256(
+        "TokenInput("
+            "address tokenIn,"
+            "uint256 netTokenIn,"
+            "address tokenMintSy,"
+            "address pendleSwap,"
+            "SwapData swapData"
+        ")"
+        "SwapData("
+            "uint8 swapType,"
+            "address extRouter,"
+            "bytes extCalldata,"
+            "bool needScale"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant MINT_SY_PAYLOAD_TYPEHASH = keccak256(
+        "MintSyPayload("
+            "TokenInput[] inps,"
+            "uint256[] minSyOuts,"
+            "uint256 expiry,"
+            "bytes32 fillParamsHash"
+        ")"
+        "SwapData("
+            "uint8 swapType,"
+            "address extRouter,"
+            "bytes extCalldata,"
+            "bool needScale"
+        ")"
+        "TokenInput("
+            "address tokenIn,"
+            "uint256 netTokenIn,"
+            "address tokenMintSy,"
+            "address pendleSwap,"
+            "SwapData swapData"
+        ")"
+    );
+
+    function _verifyMintSyData(MintSyData memory mintSyData, bytes32 fillParamsHash, address signer1, address signer2)
+        internal
+        view
+    {
+        require(block.timestamp < mintSyData.expiry, "LOP: mintSy expired");
+        require(mintSyData.fillParamsHash == fillParamsHash, "LOP: mintSy params mismatch");
+        require(mintSyData.inps.length == mintSyData.minSyOuts.length, "LOP: length mismatch");
+
+        bytes32 digest =
+            hashMintSyPayload(mintSyData.inps, mintSyData.minSyOuts, mintSyData.expiry, mintSyData.fillParamsHash);
+
+        require(SignatureChecker.isValidSignatureNow(signer1, digest, mintSyData.sig1), "LOP: bad mintSy sig1");
+        require(SignatureChecker.isValidSignatureNow(signer2, digest, mintSyData.sig2), "LOP: bad mintSy sig2");
+    }
+
+    function _hashSwapData(SwapData memory d) internal pure returns (bytes32) {
+        return keccak256(abi.encode(SWAP_DATA_TYPEHASH, d.swapType, d.extRouter, keccak256(d.extCalldata), d.needScale));
+    }
+
+    function _hashTokenInput(TokenInput memory inp) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encode(
+                TOKEN_INPUT_TYPEHASH,
+                inp.tokenIn,
+                inp.netTokenIn,
+                inp.tokenMintSy,
+                inp.pendleSwap,
+                _hashSwapData(inp.swapData)
+            )
+        );
+    }
+
+    function hashMintSyPayload(
+        TokenInput[] memory inps,
+        uint256[] memory minSyOuts,
+        uint256 expiry,
+        bytes32 fillParamsHash
+    ) public view returns (bytes32) {
+        bytes32[] memory inpHashes = new bytes32[](inps.length);
+        for (uint256 i = 0; i < inps.length; i++) {
+            inpHashes[i] = _hashTokenInput(inps[i]);
+        }
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    MINT_SY_PAYLOAD_TYPEHASH,
+                    keccak256(abi.encodePacked(inpHashes)),
+                    keccak256(abi.encodePacked(minSyOuts)),
+                    expiry,
+                    fillParamsHash
+                )
+            )
+        );
+    }
+}

package/contracts/offchain-helpers/PendleFeeSetter.sol

@@ -21,8 +21,10 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
     event SetterSet(address indexed setter);
 
     uint256 internal constant LIMIT_MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
+    uint256 internal constant POST_FILL_AMM_LN_FEE_RATE_ROOT = 999_999_500_000; // ln(1.000001)
 
     address public immutable router;
+    address public immutable postFillRouter;
     IPLimitRouter public immutable limitRouter;
     IPGovernanceProxy public immutable govProxy;
 
@@ -35,9 +37,10 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
         _;
     }
 
-    constructor(address _router, address _limitRouter, address _govProxy) {
+    constructor(address _router, address _postFillRouter, address _limitRouter, address _govProxy) {
         _disableInitializers();
         router = _router;
+        postFillRouter = _postFillRouter;
         limitRouter = IPLimitRouter(_limitRouter);
         govProxy = IPGovernanceProxy(_govProxy);
     }
@@ -50,6 +53,21 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
         _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
     }
 
+    function setPostFillRouterAMMFee(address[] memory markets) external onlyOwnerOrSetter {
+        uint256 n = markets.length;
+
+        IPGovernanceProxy.Call[] memory calls = new IPGovernanceProxy.Call[](n);
+
+        for (uint256 i = 0; i < n; ++i) {
+            calls[i].target = IPMarket(markets[i]).factory();
+            calls[i].callData = abi.encodeCall(
+                IPMarketFactory.setOverriddenFee, (postFillRouter, markets[i], POST_FILL_AMM_LN_FEE_RATE_ROOT.Uint80())
+            );
+        }
+
+        govProxy.aggregateWithScopedAccess(calls);
+    }
+
     function setFees(address[] memory markets) external onlyOwnerOrSetter {
         uint256 n = markets.length;
 

package/contracts/offchain-helpers/PendleProxyAdmin.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+
+/// @dev ProxyAdmin with configurable initial owner, since OZ's ProxyAdmin doesn't support setting owner in constructor.
+contract PendleProxyAdmin is ProxyAdmin {
+    constructor(address initialOwner) {
+        _transferOwnership(initialOwner);
+    }
+}

package/contracts/router/base/ActionBase.sol

@@ -323,10 +323,12 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         IPLimitRouter router = IPLimitRouter(lim.limitRouter);
         netLeft = netInput;
 
+        (bytes memory normalOptData, bytes memory flashOptData) = _decodeLimOptData(lim.optData);
+
         if (lim.normalFills.length != 0) {
             _safeApproveInf(address(tokenIn), lim.limitRouter);
             (uint256 actualMaking, uint256 actualTaking, uint256 totalFee,) =
-                router.fill(lim.normalFills, receiver, netLeft, lim.optData, EMPTY_BYTES);
+                router.fill(lim.normalFills, receiver, netLeft, normalOptData, EMPTY_BYTES);
             netOut += actualMaking;
             netLeft -= actualTaking;
             netSyFee += totalFee;
@@ -337,7 +339,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             OrderType orderType = lim.flashFills[0].order.orderType;
 
             (,, uint256 totalFee, bytes memory ret) = router.fill(
-                lim.flashFills, YT, type(uint256).max, lim.optData, abi.encode(orderType, YT, netLeft, receiver)
+                lim.flashFills, YT, type(uint256).max, flashOptData, abi.encode(orderType, YT, netLeft, receiver)
             );
             (uint256 netUse, uint256 netReceived) = abi.decode(ret, (uint256, uint256));
 
@@ -349,6 +351,18 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);
     }
 
+    function _decodeLimOptData(bytes memory limOptData)
+        internal
+        pure
+        returns (bytes memory normalOptData, bytes memory flashOptData)
+    {
+        if (limOptData.length != 0) {
+            (uint256 version, bytes memory payload) = abi.decode(limOptData, (uint256, bytes));
+            require(version == 1, "invalid version");
+            (normalOptData, flashOptData) = abi.decode(payload, (bytes, bytes));
+        }
+    }
+
     function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
         return a.normalFills.length == 0 && a.flashFills.length == 0;
     }

package/deployments/1-core.json

@@ -46,24 +46,21 @@
     "poolDeployHelperV2": "0xF642d8Daa026B8aEd6dFE82FACbA2E077AF199E2",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
     "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
+    "PendleChainlinkOracleFactory": "0x6502cda86f9110f3655512237C9FF2B9CE247c69",
     "experimental": {
-        "PendleChainlinkOracleFactory": "0x6502cda86f9110f3655512237C9FF2B9CE247c69",
         "PendleSparkLinearDiscountOracleFactoryWrapper": "0x9E80e2525c7289ebd6352B428f2beC53b5A4e579",
         "MarketSweed": "0x9205aCD8A2fFD56917d4b9139bA423b4f2a70EE5"
     },
-    "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "sPendle": "0x999999999991E178D52Cd95AFd4b00d066664144",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
-    "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0x33305665f69B4642D1275f4Ce81c23651674D21C",
-    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
-    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9",
     "lpWrapperFactory": "0x12930Bd944bb34B0A21CCc2E7d32a6834Bd58e19",
     "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
     "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
@@ -71,5 +68,13 @@
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x905aF80C4DE82E0075a19fDE2f5777f1A6636732"
     },
-    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4",
+    "deprecated": {
+        "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
+        "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
+        "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9",
+        "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0"
+    },
+    "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
+    "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D"
 }

package/deployments/1-offchain-helper.json

@@ -8,5 +8,5 @@
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
     "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "feeSetter": "0x95e9FC738e9C94E730536C6f28c88295d3374466"
 }

package/deployments/10-core.json

@@ -44,19 +44,19 @@
     "poolDeployHelper": "0x439B4d66255eFf74e621FBacb00D7162b588Ff4b",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
     "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0x33305665f69B4642D1275f4Ce81c23651674D21C",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
+    "PendleChainlinkOracleFactory": "0x6502cda86f9110f3655512237C9FF2B9CE247c69",
     "experimental": {
-        "PendleChainlinkOracleFactory": "0x6502cda86f9110f3655512237C9FF2B9CE247c69",
         "PendleSparkLinearDiscountOracleFactoryWrapper": "0x9E80e2525c7289ebd6352B428f2beC53b5A4e579",
         "MarketSweed": "0x9205aCD8A2fFD56917d4b9139bA423b4f2a70EE5"
     },
     "receiverEndpoint": "0xED18de5442297a4Ec1ce59C7c7d9427Adc2A012b",
-    "vePendle": "0xd5C47D2383Fddc19596489280C0A33AC42b2bB18",
     "gaugeController": "0x6875e4A945E498FE1B90BbB13CFbAF0b68658C9C",
     "expiredRedeemer": "0x8267fdabd1b8C8645138f2dE5B0fe24988DC9820",
     "lpWrapperFactory": "0xeCfEB97D7F070DA5b93c5DC274183F1D7f68532F",
@@ -66,5 +66,10 @@
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x45Dd4aEcc425b01bf98C567407aB4a4fF3C7d349"
     },
-    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
-}
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4",
+    "deprecated": {
+        "vePendle": "0xd5C47D2383Fddc19596489280C0A33AC42b2bB18"
+    },
+    "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
+    "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D"
+}

package/deployments/10-offchain-helper.json

@@ -7,5 +7,5 @@
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
     "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "feeSetter": "0x95e9FC738e9C94E730536C6f28c88295d3374466"
 }

package/deployments/130-core.json

@@ -3,8 +3,11 @@
     "network": {
         "chainId": 130,
         "wrappedNative": "0x4200000000000000000000000000000000000006",
-        "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac"
+        "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac",
+        "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
+        "hardwareDeployer": "0xeea6F790F18563E91b18DF00B89d9f79b2E6761F"
     },
+    "governanceProxy": "0x2aD631F72fB16d91c4953A7f4260A97C2fE2f31e",
     "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
     "routerFacets": {
         "ActionAddRemoveLiqV3": "0x663C21103915B68e9dA797CfdF3cAb01a037D5Ff",
@@ -17,5 +20,9 @@
         "ActionCrossChain": "0x7C082f4c2790F04F62923243Db85A1c60f768857"
     },
     "pendleSwap": "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
-    "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb"
+    "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
+    "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
+    "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
+    "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D"
 }