@pendle/core-v2 6.5.0 → 6.6.0

package/contracts/cross-chain/deposit-box/DepositBoxFactory.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+
+import {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
+import {DepositBox} from "./DepositBox.sol";
+
+contract DepositBoxFactory is IPDepositBoxFactory {
+    /// @dev creation code of OpenZeppelin's BeaconProxy
+    address public immutable BEACON_PROXY_CODE_CONTRACT;
+    address public immutable DEPOSIT_BOX_BEACON;
+    bytes32 public immutable DEPOSIT_BOX_CODE_HASH;
+
+    constructor(address beaconProxyCodeContract_, address depositBoxBeacon_) {
+        BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
+        DEPOSIT_BOX_BEACON = depositBoxBeacon_;
+        DEPOSIT_BOX_CODE_HASH =
+            keccak256(abi.encodePacked(beaconProxyCodeContract_.code, abi.encode(depositBoxBeacon_, "")));
+    }
+
+    function computeDepositBox(address owner, uint32 boxId)
+        public
+        view
+        returns (address box, bytes32 salt, bool deployed)
+    {
+        salt = keccak256(abi.encode(owner, boxId));
+        box = Create2.computeAddress(salt, DEPOSIT_BOX_CODE_HASH);
+        deployed = box.code.length > 0;
+    }
+
+    function deployDepositBox(address owner, uint32 boxId) external returns (IPDepositBox) {
+        (address box, bytes32 salt, bool deployed) = computeDepositBox(owner, boxId);
+        if (deployed) {
+            return IPDepositBox(box);
+        }
+
+        bytes memory bytecode = abi.encodePacked(BEACON_PROXY_CODE_CONTRACT.code, abi.encode(DEPOSIT_BOX_BEACON, ""));
+        assert(Create2.deploy(0, salt, bytecode) == box);
+        DepositBox(payable(box)).initialize(owner, boxId);
+        return IPDepositBox(box);
+    }
+}

package/contracts/cross-chain/swap-hub/PendleCrossChainSwapHub.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {SwapHubBase} from "./SwapHubBase.sol";
+
+contract PendleCrossChainSwapHub is SwapHubBase {
+    constructor(address treasury_, address depositBoxFactory_) SwapHubBase(treasury_, depositBoxFactory_) {
+        _disableInitializers();
+    }
+
+    function initialize(address _owner) external initializer {
+        __EIP712_init("Pendle Cross Chain Swap Hub", "1");
+        __BoringOwnableV2_init(_owner);
+    }
+
+    function withdrawToken(WithdrawTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
+        _payTreasury(box, ms.token, ms.amountFee);
+        _withdrawToken(ms, box);
+
+        emit WithdrawToken(
+            ms.permit.owner,
+            ms.permit.boxId,
+            ms.permit.requestId,
+            ms.permit.nonce,
+            ms.token,
+            ms.amountWithdraw,
+            ms.amountFee
+        );
+    }
+
+    function bridgeToken(BridgeTokenMessage memory ms, bytes memory sig) external payable onlyExecutor {
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
+        _payTreasury(box, ms.token, ms.amountFee);
+        _bridgeToken(ms, box, msg.value);
+
+        emit BridgeToken(
+            ms.permit.owner,
+            ms.permit.boxId,
+            ms.permit.requestId,
+            ms.permit.nonce,
+            ms.bridgeExtRouter,
+            ms.token,
+            ms.amountBridge,
+            ms.amountFee
+        );
+    }
+
+    function swapToken(SwapTokenMessage memory ms, bytes memory sig) external onlyExecutor {
+        IPDepositBox box = _checkBoxPermit(ms.permit, hashTypedData(ms), sig);
+        // swapToken does not pay treasury
+
+        uint256 netTokenReceived = _swapToken(ms, box);
+        require(netTokenReceived >= ms.minReceived, InsufficientTokenReceived());
+
+        emit SwapToken(
+            ms.permit.owner,
+            ms.permit.boxId,
+            ms.permit.requestId,
+            ms.permit.nonce,
+            ms.tokenSpent,
+            ms.amountSpent,
+            ms.tokenReceived,
+            netTokenReceived
+        );
+    }
+
+    function _payTreasury(IPDepositBox box, address token, uint256 amount) internal {
+        box.withdrawTo(TREASURY, token, amount);
+    }
+
+    function _withdrawToken(WithdrawTokenMessage memory ms, IPDepositBox box) internal {
+        box.withdrawTo(ms.permit.owner, ms.token, ms.amountWithdraw);
+    }
+
+    function _bridgeToken(BridgeTokenMessage memory ms, IPDepositBox box, uint256 nativeFee) internal {
+        ApprovedCall memory call = ApprovedCall({
+            token: ms.token,
+            amount: ms.amountBridge,
+            approveTo: ms.bridgeApprove,
+            callTo: ms.bridgeExtRouter,
+            data: ms.bridgeCalldata
+        });
+        box.approveAndCall{value: nativeFee}(call, msg.sender);
+    }
+
+    function _swapToken(SwapTokenMessage memory ms, IPDepositBox box) internal returns (uint256 rawTokenReceived) {
+        ApprovedCall memory call = ApprovedCall({
+            token: ms.tokenSpent,
+            amount: ms.amountSpent,
+            approveTo: ms.swapApprove,
+            callTo: ms.swapExtRouter,
+            data: ms.swapCalldata
+        });
+
+        uint256 preBalance = _balanceOf(address(box), ms.tokenReceived);
+        box.approveAndCall(call, address(box));
+        rawTokenReceived = _balanceOf(address(box), ms.tokenReceived) - preBalance;
+    }
+}

package/contracts/cross-chain/swap-hub/SwapHubBase.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
+import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {IPCrossChainSwapHub} from "../../interfaces/IPCrossChainSwapHub.sol";
+import {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
+
+abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
+    // forgefmt: disable-next-item
+    bytes32 internal constant BOX_PERMIT_TYPEHASH = keccak256(
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant WITHDRAW_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "WithdrawTokenMessage("
+            "BoxPermit permit,"
+            "address token,"
+            "uint256 amountWithdraw,"
+            "uint256 amountFee"
+        ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "BridgeTokenMessage("
+            "BoxPermit permit,"
+            "address token,"
+            "uint256 amountBridge,"
+            "uint256 amountFee,"
+            //
+            "address bridgeExtRouter,"
+            "address bridgeApprove,"
+            "bytes bridgeCalldata"
+        ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant SWAP_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "SwapTokenMessage("
+            "BoxPermit permit,"
+            "address tokenSpent,"
+            "uint256 amountSpent,"
+            "address tokenReceived,"
+            "uint256 minReceived,"
+            //
+            "address swapExtRouter,"
+            "address swapApprove,"
+            "bytes swapCalldata"
+        ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    address public immutable TREASURY;
+    IPDepositBoxFactory public immutable DEPOSIT_BOX_FACTORY;
+
+    address public executor;
+    address public proposer;
+    mapping(uint256 requestId => uint256 nonce) public requestNonce;
+
+    constructor(address treasury_, address depositBoxFactory_) {
+        TREASURY = treasury_;
+        DEPOSIT_BOX_FACTORY = IPDepositBoxFactory(depositBoxFactory_);
+    }
+
+    modifier onlyExecutor() {
+        require(msg.sender == executor, Unauthorized());
+        _;
+    }
+
+    function setExecutor(address executor_) external onlyOwner {
+        executor = executor_;
+        emit SetExecutor(executor);
+    }
+
+    function setProposer(address proposer_) external onlyOwner {
+        proposer = proposer_;
+        emit SetProposer(proposer);
+    }
+
+    function hashBoxPermit(BoxPermit memory permit) public pure returns (bytes32) {
+        return keccak256(
+            abi.encode(BOX_PERMIT_TYPEHASH, permit.owner, permit.boxId, permit.expiry, permit.requestId, permit.nonce)
+        );
+    }
+
+    function hashTypedData(WithdrawTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    WITHDRAW_TOKEN_MESSAGE_TYPEHASH, hashBoxPermit(ms.permit), ms.token, ms.amountWithdraw, ms.amountFee
+                )
+            )
+        );
+    }
+
+    function hashTypedData(BridgeTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    BRIDGE_TOKEN_MESSAGE_TYPEHASH,
+                    hashBoxPermit(ms.permit),
+                    ms.token,
+                    ms.amountBridge,
+                    ms.amountFee,
+                    //
+                    ms.bridgeExtRouter,
+                    ms.bridgeApprove,
+                    keccak256(ms.bridgeCalldata)
+                )
+            )
+        );
+    }
+
+    function hashTypedData(SwapTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    SWAP_TOKEN_MESSAGE_TYPEHASH,
+                    hashBoxPermit(ms.permit),
+                    ms.tokenSpent,
+                    ms.amountSpent,
+                    ms.tokenReceived,
+                    ms.minReceived,
+                    //
+                    ms.swapExtRouter,
+                    ms.swapApprove,
+                    keccak256(ms.swapCalldata)
+                )
+            )
+        );
+    }
+
+    function _verifyProposerSig(
+        uint256 expiry,
+        uint256 requestId,
+        uint256 nonce,
+        bytes32 messageHash,
+        bytes memory signature
+    ) internal {
+        require(expiry > block.timestamp, MessageExpired());
+        require(SignatureChecker.isValidSignatureNow(proposer, messageHash, signature), InvalidSignature());
+        require(requestNonce[requestId] == nonce, InvalidNonce());
+        requestNonce[requestId] = nonce + 1;
+    }
+
+    function _checkBoxPermit(BoxPermit memory permit, bytes32 messageHash, bytes memory signature)
+        internal
+        returns (IPDepositBox)
+    {
+        _verifyProposerSig(permit.expiry, permit.requestId, permit.nonce, messageHash, signature);
+        return DEPOSIT_BOX_FACTORY.deployDepositBox(permit.owner, permit.boxId);
+    }
+}

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCrossChainSwapHub {
+    error InsufficientTokenReceived();
+    error InvalidNonce();
+    error InvalidSignature();
+    error MessageExpired();
+    error Unauthorized();
+
+    struct BoxPermit {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 requestId;
+        uint256 nonce;
+    }
+
+    struct WithdrawTokenMessage {
+        BoxPermit permit;
+        address token;
+        uint256 amountWithdraw;
+        uint256 amountFee;
+    }
+
+    struct BridgeTokenMessage {
+        BoxPermit permit;
+        address token;
+        uint256 amountBridge;
+        uint256 amountFee;
+        //
+        address bridgeExtRouter;
+        address bridgeApprove;
+        bytes bridgeCalldata;
+    }
+
+    struct SwapTokenMessage {
+        BoxPermit permit;
+        address tokenSpent;
+        uint256 amountSpent;
+        address tokenReceived;
+        uint256 minReceived;
+        //
+        address swapExtRouter;
+        address swapApprove;
+        bytes swapCalldata;
+    }
+
+    event WithdrawToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address token,
+        uint256 amountWithdraw,
+        uint256 amountFee
+    );
+
+    event BridgeToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address bridgeExtRouter,
+        address token,
+        uint256 amountBridge,
+        uint256 amountFee
+    );
+
+    event SwapToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        uint256 netTokenReceived
+    );
+
+    event SetExecutor(address executor);
+
+    event SetProposer(address proposer);
+
+    function executor() external view returns (address);
+
+    function proposer() external view returns (address);
+
+    function setExecutor(address executor) external;
+
+    function setProposer(address proposer) external;
+
+    function requestNonce(uint256 requestId) external view returns (uint256);
+
+    function hashBoxPermit(BoxPermit memory permit) external view returns (bytes32);
+
+    function hashTypedData(WithdrawTokenMessage memory message) external view returns (bytes32);
+
+    function hashTypedData(BridgeTokenMessage memory message) external view returns (bytes32);
+
+    function hashTypedData(SwapTokenMessage memory message) external view returns (bytes32);
+
+    function withdrawToken(WithdrawTokenMessage memory message, bytes memory signature) external;
+
+    function bridgeToken(BridgeTokenMessage memory message, bytes memory signature) external payable;
+
+    function swapToken(SwapTokenMessage memory message, bytes memory signature) external;
+}

package/contracts/interfaces/IPDepositBox.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+struct ApprovedCall {
+    address token;
+    uint256 amount;
+    address approveTo;
+    address callTo;
+    bytes data;
+}
+
+interface IPDepositBox {
+    function MANAGER() external view returns (address);
+
+    function OWNER() external view returns (address);
+
+    function BOX_ID() external view returns (uint32);
+
+    function withdrawTo(address to, address token, uint256 amount) external;
+
+    function approveAndCall(ApprovedCall memory call, address nativeRefund) external payable returns (bytes memory);
+}

package/contracts/interfaces/IPDepositBoxFactory.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPDepositBox} from "./IPDepositBox.sol";
+
+interface IPDepositBoxFactory {
+    function computeDepositBox(address owner, uint32 boxId)
+        external
+        view
+        returns (address box, bytes32 salt, bool deployed);
+
+    function deployDepositBox(address owner, uint32 boxId) external returns (IPDepositBox box);
+
+    function BEACON_PROXY_CODE_CONTRACT() external view returns (address);
+
+    function DEPOSIT_BOX_BEACON() external view returns (address);
+
+    function DEPOSIT_BOX_CODE_HASH() external view returns (bytes32);
+}

package/contracts/interfaces/IPGaugeController.sol

@@ -12,6 +12,8 @@ interface IPGaugeController {
 
     event UpdateMarketRewardV2(address indexed market, uint128 pendlePerSec, uint128 incentiveEndsAt);
 
+    event WhitelistMarketSet(address indexed market, bool isWhitelisted);
+
     function setRewardDatas(
         address[] calldata markets,
         uint128[] calldata pendlePerSecs,
@@ -24,10 +26,12 @@ interface IPGaugeController {
 
     function redeemMarketReward() external;
 
-    function rewardData(
-        address market
-    )
+    function rewardData(address market)
         external
         view
         returns (uint128 pendlePerSec, uint128 accumulatedPendle, uint128 lastUpdated, uint128 incentiveEndsAt);
+
+    function isWhitelisted(address market) external view returns (bool);
+
+    function whitelistMarkets(address[] memory markets, bool _isWhitelisted) external;
 }

package/contracts/interfaces/IPLimitRouter.sol

@@ -71,6 +71,9 @@ interface IPLimitRouter is IPLimitOrderType {
         uint128 remaining;
     }
 
+    // event added on 11/3/2026
+    event OrderPreSigned(bytes32 indexed orderHash, Order order);
+
     event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
 
     event OrderForceCanceled(bytes32 indexed orderHash);
@@ -104,6 +107,10 @@ interface IPLimitRouter is IPLimitOrderType {
 
     function hashOrder(Order memory order) external view returns (bytes32);
 
+    function preSignSingle(Order calldata order) external;
+
+    function preSignBatch(Order[] calldata order) external;
+
     function cancelSingle(Order calldata order) external;
 
     function cancelBatch(Order[] calldata orders) external;

package/contracts/limit/LimitRouterBase.sol

@@ -42,15 +42,10 @@ abstract contract LimitRouterBase is
 
     mapping(bytes32 => OrderStatus) internal _status;
 
-    address public ownerHelper;
+    address private __deprecated__ownerHelper;
 
     uint256[99] private __gap;
 
-    modifier onlyHelperAndOwner() {
-        require(msg.sender == ownerHelper || msg.sender == owner, "not allowed");
-        _;
-    }
-
     constructor(address _WNATIVE) {
         WNATIVE = _WNATIVE;
     }
@@ -460,14 +455,10 @@ abstract contract LimitRouterBase is
         feeRecipient = _feeRecipient;
     }
 
-    function setOwnerHelper(address _helper) public onlyOwner {
-        ownerHelper = _helper;
-    }
-
     /// @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) {
         _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/deployments/1-core.json

@@ -50,20 +50,16 @@
     "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 +67,13 @@
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x905aF80C4DE82E0075a19fDE2f5777f1A6636732"
     },
-    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4",
+    "deprecated": {
+        "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
+        "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
+        "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9",
+        "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0"
+    },
+    "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
+    "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D"
 }

package/deployments/10-core.json

@@ -50,13 +50,12 @@
     "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 +65,10 @@
         "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x45Dd4aEcc425b01bf98C567407aB4a4fF3C7d349"
     },
-    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
-}
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4",
+    "deprecated": {
+        "vePendle": "0xd5C47D2383Fddc19596489280C0A33AC42b2bB18"
+    },
+    "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
+    "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D"
+}