@pendle/core-v2 6.4.1-unichain → 6.4.2-swaphubtest

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

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+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 {ApprovedCall, IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {DepositBox} from "./DepositBox.sol";
+
+abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
+    // forgefmt: disable-next-item
+    bytes32 internal constant WITHDRAW_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "WithdrawTokenMessage("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 nonce,"
+            //
+            "address token,"
+            "uint256 amountWithdraw,"
+            "uint256 amountFee"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "BridgeTokenMessage("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 nonce,"
+            //
+            "address token,"
+            "uint256 amountBridge,"
+            "uint256 amountFee,"
+            "bool pullFromOwner,"
+            //
+            "address bridgeExtRouter,"
+            "address bridgeApprove,"
+            "bytes bridgeCalldata"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant SWAP_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "SwapTokenMessage("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 nonce,"
+            //
+            "address tokenSpent,"
+            "uint256 amountSpent,"
+            "uint256 amountFee,"
+            "address tokenReceived,"
+            "uint256 minReceived,"
+            "bool pullFromOwner,"
+            "bool sendToOwner,"
+            //
+            "address swapExtRouter,"
+            "address swapApprove,"
+            "bytes swapCalldata"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH = keccak256(
+        "BuyCrossChainPtMessage("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 nonce,"
+            //
+            "address tokenSpent,"
+            "uint256 amountSpent,"
+            "uint256 amountFee,"
+            "address ptAdapter,"
+            "uint256 minPtReceived,"
+            "uint32 dstEid,"
+            "bytes32 receiver,"
+            "bool pullFromOwner,"
+            //
+            "address swapExtRouter,"
+            "address swapApprove,"
+            "bytes swapCalldata"
+        ")"
+    );
+
+    address public immutable TREASURY;
+
+    /// @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;
+
+    mapping(address owner => uint256 nonce) public ownerNonce;
+    mapping(address executor => bool) public isExecutor;
+
+    constructor(address treasury_, address beaconProxyCodeContract_, address depositBoxBeacon_) {
+        TREASURY = treasury_;
+        BEACON_PROXY_CODE_CONTRACT = beaconProxyCodeContract_;
+        DEPOSIT_BOX_BEACON = depositBoxBeacon_;
+        DEPOSIT_BOX_CODE_HASH =
+            keccak256(abi.encodePacked(beaconProxyCodeContract_.code, abi.encode(depositBoxBeacon_, "")));
+    }
+
+    modifier onlyExecutor() {
+        require(isExecutor[msg.sender], "SwapHub: caller is not executor");
+        _;
+    }
+
+    function setExecutor(address executor, bool isExecutor_) external onlyOwner {
+        isExecutor[executor] = isExecutor_;
+        emit SetExecutor(executor, isExecutor_);
+    }
+
+    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 _checkAndDeployBox(address owner, uint32 boxId) internal 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);
+    }
+
+    function hashTypedData(WithdrawTokenMessage memory message) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    WITHDRAW_TOKEN_MESSAGE_TYPEHASH,
+                    message.owner,
+                    message.boxId,
+                    message.expiry,
+                    message.nonce,
+                    //
+                    message.token,
+                    message.amountWithdraw,
+                    message.amountFee
+                )
+            )
+        );
+    }
+
+    function hashTypedData(BridgeTokenMessage memory message) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    BRIDGE_TOKEN_MESSAGE_TYPEHASH,
+                    message.owner,
+                    message.boxId,
+                    message.expiry,
+                    message.nonce,
+                    //
+                    message.token,
+                    message.amountBridge,
+                    message.amountFee,
+                    message.pullFromOwner,
+                    //
+                    message.bridgeExtRouter,
+                    message.bridgeApprove,
+                    keccak256(message.bridgeCalldata)
+                )
+            )
+        );
+    }
+
+    function hashTypedData(SwapTokenMessage memory message) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    SWAP_TOKEN_MESSAGE_TYPEHASH,
+                    message.owner,
+                    message.boxId,
+                    message.expiry,
+                    message.nonce,
+                    //
+                    message.tokenSpent,
+                    message.amountSpent,
+                    message.amountFee,
+                    message.tokenReceived,
+                    message.minReceived,
+                    message.pullFromOwner,
+                    message.sendToOwner,
+                    //
+                    message.swapExtRouter,
+                    message.swapApprove,
+                    keccak256(message.swapCalldata)
+                )
+            )
+        );
+    }
+
+    function hashTypedData(BuyCrossChainPtMessage memory message) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    BUY_CROSS_CHAIN_PT_MESSAGE_TYPEHASH,
+                    message.owner,
+                    message.boxId,
+                    message.expiry,
+                    message.nonce,
+                    //
+                    message.tokenSpent,
+                    message.amountSpent,
+                    message.amountFee,
+                    message.ptAdapter,
+                    message.minPtReceived,
+                    message.dstEid,
+                    message.receiver,
+                    message.pullFromOwner,
+                    //
+                    message.swapExtRouter,
+                    message.swapApprove,
+                    keccak256(message.swapCalldata)
+                )
+            )
+        );
+    }
+
+    function _verifyOwnerSig(address owner, uint256 expiry, uint256 nonce, bytes32 messageHash, bytes memory signature)
+        internal
+    {
+        require(SignatureChecker.isValidSignatureNow(owner, messageHash, signature), InvalidSignature());
+        require(expiry > block.timestamp, MessageExpired());
+        require(ownerNonce[owner] < nonce, InvalidNonce());
+        ownerNonce[owner] = nonce;
+    }
+
+    function _swapFromBox(
+        IPDepositBox box,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        address swapExtRouter,
+        address swapApprove,
+        bytes memory swapCalldata,
+        address receiver
+    ) internal returns (uint256 rawTokenReceived) {
+        // forgefmt: disable-next-item
+        ApprovedCall memory call = ApprovedCall({
+            token: tokenSpent,
+            amount: amountSpent,
+            approveTo: swapApprove,
+            callTo: swapExtRouter,
+            data: swapCalldata
+        });
+
+        uint256 preBalance = _selfBalance(tokenReceived);
+        box.approveAndCall(call, address(box));
+        rawTokenReceived = _selfBalance(tokenReceived) - preBalance;
+
+        _transferOut(tokenReceived, receiver, rawTokenReceived);
+    }
+
+    function _addressToBytes32(address addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(addr)));
+    }
+}

package/contracts/interfaces/IPActionCrossChain.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {TokenOutput} from "./IPAllActionTypeV3.sol";
+
+interface IPActionCrossChain {
+    function swapWithFixedPricePTAMM(
+        address receiver,
+        address fixedPricePTAMM,
+        address PT,
+        uint256 exactPtIn,
+        TokenOutput calldata out
+    ) external returns (uint256 netTokenOut);
+}

package/contracts/interfaces/IPAllActionV3.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.0;
 
 import "./IPActionAddRemoveLiqV3.sol";
 import "./IPActionCallbackV3.sol";
+import "./IPActionCrossChain.sol";
 import "./IPActionMiscV3.sol";
 import "./IPActionSimple.sol";
 import "./IPActionStorageV4.sol";
@@ -17,5 +18,6 @@ interface IPAllActionV3 is
     IPActionMiscV3,
     IPActionCallbackV3,
     IPActionStorageV4,
-    IPActionSimple
+    IPActionSimple,
+    IPActionCrossChain
 {}

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCrossChainSwapHub {
+    error InsufficientTokenReceived();
+    error InvalidNonce();
+    error InvalidSignature();
+    error InvalidReceiver();
+    error MessageExpired();
+
+    struct WithdrawTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address token;
+        uint256 amountWithdraw;
+        uint256 amountFee;
+    }
+
+    struct BridgeTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address token;
+        uint256 amountBridge;
+        uint256 amountFee;
+        bool pullFromOwner;
+        //
+        address bridgeExtRouter;
+        address bridgeApprove;
+        bytes bridgeCalldata;
+    }
+
+    struct SwapTokenMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address tokenSpent;
+        uint256 amountSpent;
+        uint256 amountFee;
+        address tokenReceived;
+        uint256 minReceived;
+        bool pullFromOwner;
+        bool sendToOwner;
+        //
+        address swapExtRouter;
+        address swapApprove;
+        bytes swapCalldata;
+    }
+
+    struct BuyCrossChainPtMessage {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+        //
+        address tokenSpent;
+        uint256 amountSpent;
+        uint256 amountFee;
+        address ptAdapter;
+        uint256 minPtReceived;
+        uint32 dstEid;
+        bytes32 receiver;
+        bool pullFromOwner;
+        //
+        address swapExtRouter;
+        address swapApprove;
+        bytes swapCalldata;
+    }
+
+    event WithdrawToken(address indexed owner, uint32 boxId, address token, uint256 amountWithdraw, uint256 amountFee);
+
+    event BridgeToken(
+        address indexed owner,
+        uint32 boxId,
+        address bridgeExtRouter,
+        address token,
+        uint256 amountBridge,
+        uint256 amountFee,
+        bool pullFromOwner
+    );
+
+    event SwapToken(
+        address indexed owner,
+        uint32 boxId,
+        address tokenSpent,
+        uint256 amountSpent,
+        uint256 amountFee,
+        address tokenReceived,
+        uint256 netTokenReceived,
+        bool pullFromOwner,
+        bool sendToOwner
+    );
+
+    event BuyCrossChainPt(
+        address indexed owner,
+        uint32 boxId,
+        address tokenSpent,
+        uint256 amountSpent,
+        uint256 amountFee,
+        address ptAdapter,
+        address pt,
+        uint256 netPtReceived,
+        bool pullFromOwner
+    );
+
+    event SetExecutor(address indexed executor, bool isExecutor);
+
+    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);
+
+    function ownerNonce(address owner) external view returns (uint256);
+
+    function isExecutor(address executor) external view returns (bool);
+
+    function computeDepositBox(address owner, uint32 boxId)
+        external
+        view
+        returns (address box, bytes32 salt, bool deployed);
+
+    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 hashTypedData(BuyCrossChainPtMessage 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;
+
+    function buyCrossChainPt(BuyCrossChainPtMessage memory message, bytes memory signature) external payable;
+
+    function setExecutor(address executor, bool isExecutor) 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/router/ActionCrossChain.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {ActionBase} from "./base/ActionBase.sol";
+import {TokenOutput, IPActionCrossChain} from "../interfaces/IPActionCrossChain.sol";
+import {IPFixedPricePTAMM} from "../interfaces/IPFixedPricePTAMM.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SwapType, IPSwapAggregator} from "./swap-aggregator/IPSwapAggregator.sol";
+
+contract ActionCrossChain is ActionBase, IPActionCrossChain {
+    function swapWithFixedPricePTAMM(
+        address receiver,
+        address fixedPricePTAMM,
+        address PT,
+        uint256 exactPtIn,
+        TokenOutput calldata out
+    ) external returns (uint256 netTokenOut) {
+        _transferFrom(IERC20(PT), msg.sender, fixedPricePTAMM, exactPtIn);
+        uint256 tokenOut = IPFixedPricePTAMM(fixedPricePTAMM).swapExactPtForToken(
+            __swapDestination(receiver, out),
+            PT,
+            exactPtIn,
+            out.tokenRedeemSy,
+            EMPTY_BYTES
+        );
+        return __handleTokenOutput(receiver, tokenOut, out);
+    }
+
+    /// @notice __swapDestination and __handleTokenOutput provide an alternative way to implement __redeemSyToToken
+    /// ```solidity
+    /// SwapType swapType = out.swapData.swapType;
+    /// address redeemSyReceiver = __swapDestination(receiver, out);
+    /// uint256 netTokenRedeemed = __redeemSy(redeemSyReceiver, SY, netSyIn, out, doPull);
+    /// return __handleTokenOutput(receiver, netTokenRedeemed, out);
+    /// ```
+    /// We keep the old implementation of __redeemSyToToken as a stable implementation
+    function __swapDestination(address receiver, TokenOutput calldata out) internal view returns (address) {
+        SwapType swapType = out.swapData.swapType;
+        if (swapType == SwapType.NONE) return receiver;
+        else if (swapType == SwapType.ETH_WETH) return address(this);
+        else return out.pendleSwap;
+    }
+
+    /// @dev The caller must ensure that the address returned by `__swapDestination(...)` has `netTokenRedeemSy` amount of `out.tokenRedeemSy` tokens before calling this function.
+    function __handleTokenOutput(
+        address receiver,
+        uint256 netTokenRedeemSy,
+        TokenOutput calldata out
+    ) internal returns (uint256 netTokenOut) {
+        SwapType swapType = out.swapData.swapType;
+        if (swapType == SwapType.NONE) netTokenOut = netTokenRedeemSy;
+        else if (swapType == SwapType.ETH_WETH) {
+            netTokenOut = netTokenRedeemSy; // ETH:WETH is 1:1
+            _wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        } else {
+            IPSwapAggregator(out.pendleSwap).swap(out.tokenRedeemSy, netTokenRedeemSy, out.swapData);
+            netTokenOut = _selfBalance(out.tokenOut);
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        }
+        if (netTokenOut < out.minTokenOut) revert("Slippage: INSUFFICIENT_TOKEN_OUT");
+    }
+}

package/contracts/router/Reflector.sol

@@ -16,7 +16,7 @@ contract Reflector is TokenHelper, IPReflector {
     receive() external payable {}
 
     function reflect(bytes calldata inputData) external returns (bytes memory result) {
-        (uint256 value, bytes memory newCalldata) = _getNewCalldata(inputData);
+        (uint256 value, bytes memory newCalldata, address receiver, address market) = _getNewCalldata(inputData);
         bool success;
 
         (success, result) = ROUTER.call{value: value}(newCalldata);
@@ -26,9 +26,14 @@ contract Reflector is TokenHelper, IPReflector {
                 revert(add(32, result), mload(result))
             }
         }
+
+        if (market != address(0)) _sweepMarketDustBalance(receiver, market);
     }
 
-    function _getNewCalldata(bytes calldata inputData) internal returns (uint256 value, bytes memory newCalldata) {
+    function _getNewCalldata(bytes calldata inputData)
+        internal
+        returns (uint256 value, bytes memory newCalldata, address receiver, address market)
+    {
         bytes4 selector = bytes4(inputData[:4]);
         bytes calldata data = inputData[4:];
 
@@ -48,12 +53,14 @@ contract Reflector is TokenHelper, IPReflector {
 
             value = _scaleTokenInputAndGetValue(v5);
             newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5, v6);
+            (receiver, market) = (v1, v2);
         } 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);
+            (receiver, market) = (v1, v2);
         } else if (
             selector == IPActionAddRemoveLiqV3.addLiquiditySingleSy.selector
                 || selector == IPActionSwapPTV3.swapExactSyForPt.selector
@@ -63,11 +70,13 @@ contract Reflector is TokenHelper, IPReflector {
                 abi.decode(data, (address, address, uint256, uint256, ApproxParams, LimitOrderData));
 
             newCalldata = abi.encodeWithSelector(selector, v1, v2, _scaleSyInput(v2), v4, v5, v6);
+            (receiver, market) = (v1, v2);
         } else if (selector == IPActionAddRemoveLiqV3.addLiquiditySingleSyKeepYt.selector) {
             (address v1, address v2,, uint256 v4, uint256 v5) =
                 abi.decode(data, (address, address, uint256, uint256, uint256));
 
             newCalldata = abi.encodeWithSelector(selector, v1, v2, _scaleSyInput(v2), v4, v5);
+            (receiver, market) = (v1, v2);
         } else {
             revert("UNSUPPORTED_SELECTOR");
         }
@@ -97,4 +106,12 @@ contract Reflector is TokenHelper, IPReflector {
             approved[address(SY)] = true;
         }
     }
+
+    function _sweepMarketDustBalance(address receiver, address market) internal {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        _transferOut(address(SY), receiver, _selfBalance(SY));
+        _transferOut(address(PT), receiver, _selfBalance(PT));
+        _transferOut(address(YT), receiver, _selfBalance(YT));
+    }
 }

package/contracts/router/swap-aggregator/OKXScaleHelper.sol

@@ -45,6 +45,9 @@ abstract contract OKXScaleHelper {
         if (chainid == 9745) {
             return 0x9FD43F5E4c24543b2eBC807321E58e6D350d6a5A;
         }
+        if (chainid == 130) {
+            return 0x2e28281Cf3D58f475cebE27bec4B8a23dFC7782c;
+        }
         return address(0);
     }
 
@@ -283,7 +286,10 @@ interface IOKXDexRouter {
         uint256 minReturn,
         // solhint-disable-next-line no-unused-vars
         bytes32[] calldata pools
-    ) external payable returns (uint256 returnAmount);
+    )
+        external
+        payable
+        returns (uint256 returnAmount);
 
     function smartSwapByOrderId(
         uint256 orderId,

package/deployments/1-core.json

@@ -46,7 +46,7 @@
     "poolDeployHelperV2": "0xF642d8Daa026B8aEd6dFE82FACbA2E077AF199E2",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",

package/deployments/10-core.json

@@ -44,7 +44,7 @@
     "poolDeployHelper": "0x439B4d66255eFf74e621FBacb00D7162b588Ff4b",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0x33305665f69B4642D1275f4Ce81c23651674D21C",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",

package/deployments/130-core.json

@@ -1,9 +1,20 @@
 {
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": {
-        "chainId": 130
+        "chainId": 130,
+        "wrappedNative": "0x4200000000000000000000000000000000000006"
     },
     "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
+    "routerFacets": {
+        "ActionAddRemoveLiqV3": "0x663C21103915B68e9dA797CfdF3cAb01a037D5Ff",
+        "ActionSwapPTV3": "0xd8D200d9A713A1c71cF1e7F694B14E5F1D948b15",
+        "ActionSwapYTV3": "0x4a03Ce0a268951d04E187B1CF48075eE69266e27",
+        "ActionMiscV3": "0x373Dba2055Ad40cb4815148bC47cd1DC16e92E44",
+        "ActionSimple": "0x852e59252c94716F0df19B52b36512f6C9297a96",
+        "ActionCallbackV3": "0x7b78F36aBf6cF3C6C0dd54716dFeF0607ae17846",
+        "ActionStorageV4": "0xdED51dca2ECED7a0BAab3D9711A87f214769Da0f",
+        "ActionCrossChain": "0x7C082f4c2790F04F62923243Db85A1c60f768857"
+    },
     "pendleSwap": "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb"
 }

package/deployments/130-offchain-helper.json

@@ -0,0 +1,9 @@
+{
+  "pendleMulticallV2": "0x1ca3352a55A3D69cA8e5aB06006e08aaF2bD09f1",
+  "implicitSwapfeeContract": "0x82Fae57b2A79D893D88488A7D8BdF2AC6bd2C463",
+  "simulateHelper": "0xc23Dd2807e51dd1D317e1321CBeEb9ace98531EE",
+  "supperCapReader": "0x251CfB4E84CefecA6c1e6a4D8a0cb9c524e7484f",
+  "limitBackendHelperV2": "0xE3667BF5a5d8076c7a6e8b57C525150E4aFAe578",
+  "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438"
+}
+