双 WebSocket 架构设计文档（K 线主网 + 订单/用户推送随配置）

1. 目标与约束

背景：原单 WebSocket 连接主网；当 TRADING_NETWORK=testnet 时订单在测试网提交，但推送仍来自主网，导致收不到测试网 orderUpdates/userFills，持仓/余额数据与测试网不一致。本设计拆分为 Market WS（主网固定）+ Trading WS（随配置）解决该问题。

需求

• K 线与 L2 订单簿：始终连接主网 WebSocket（wss://api.hyperliquid.xyz/ws），与 TRADING_NETWORK 无关。
• orderUpdates / userFills / user：连接随 TRADING_NETWORK 变化的 WebSocket（testnet 时 wss://api.hyperliquid-testnet.xyz/ws，mainnet 时与主网一致）。

非目标：不改变现有交易 HTTP API、订单状态机与 WebSocketOrderManager 的对外行为。

实现原则（必守）

• 按重写执行：相关方法按下文「契约与删除清单」重写，不以补丁方式实现；实现后单 WS 与订单同网的任何分支、注释零残留。
• 不保留兼容路径：不保留「若未传 ws_url 则用全局 URL」「若未传 source_name 则用 websocket」的默认值；两处创建 EnhancedWebSocketManager 时必须显式传入 ws_url 与 source_name。
• 事件 source 合法取值仅两种："market"、"trading"。实现后全局禁止出现 source="websocket"。

安全默认值：TRADING_NETWORK 默认值为 "mainnet"，防止忘记配置时静默连到测试网下单。

架构范围：仅采用双 WebSocket（行情 WS + 交易 WS），不考虑单 WS 回滚。

2. 目标架构

以下为唯一实现形态；实现后不存在单 WS 分支、不存在按配置切换单/双 WS 的逻辑。

flowchart LR
  subgraph config [Config]
    WS_MARKET_URL["WS_MARKET_URL (主网固定)"]
    WS_TRADING_URL["WS_TRADING_URL (随 TRADING_NETWORK)"]
  end

  subgraph market [Market WS — 主网]
    Mgr1["EnhancedWebSocketManager\nsource='market'"]
    Mgr1 -->|订阅| Sub1[candle / l2Book]
    Mgr1 -->|WS_MARKET_URL| HL_M[Hyperliquid Mainnet]
  end

  subgraph trading [Trading WS — 随配置]
    Mgr2["EnhancedWebSocketManager\nsource='trading'"]
    Mgr2 -->|订阅| Sub2[orderUpdates / userFills / user]
    Mgr2 -->|WS_TRADING_URL| HL_T[Hyperliquid Testnet/Mainnet]
  end

  config --> Mgr1
  config --> Mgr2

  Mgr1 -->|on_message| Kline[K 线 + L2 处理]
  Mgr1 -->|EventBus source=market| EB[全局 EventBus]
  Mgr2 -->|_cache_latest_data 发布 无 message 回调| EB
  EB -->|OrderStatusEvent/OrderFilledEvent| OrderMgr[WebSocketOrderManager]
  EB -->|过滤 source=trading| Exec[Executor]

核心设计决策：

1. Market WS：仅订阅 candle、l2Book；URL 固定主网（WS_MARKET_URL）；source="market"。
2. Trading WS：仅订阅 orderUpdates、userFills、user；URL 为 WS_TRADING_URL；source="trading"。
3. 订单/用户数据流：仅通过 EventBus。orderUpdates/userFills 在 Trading WS 的 _cache_latest_data 内发布 OrderStatusEvent/OrderFilledEvent；WebSocketOrderManager 仅通过订阅上述事件接收，不存在「原始 WS 消息 → handle_message」的调用。
4. EventBus：保持全局单例；executor 的 handler 仅处理 source="trading" 的事件。

3. 数据流

3.1 行情（Market WS）

主网 WS → _wrapped_callback()
  1. _cache_latest_data() → CandleUpdatedEvent(source="market")、OrderBookUpdatedEvent(source="market") → EventBus + L2 缓存更新
  2. on_message() → K 线解析 → kline_buffer → 分析入队

get_market_ws_manager() 返回该 manager，L2 缓存基于主网数据，供 executor 的 get_all_mids() 等读取。

3.2 订单与用户（Trading WS）

交易网 WS → _wrapped_callback()
  → _cache_latest_data():
     - orderUpdates → _publish_order_status_events() → OrderStatusEvent(source="trading")   → EventBus → WebSocketOrderManager 订阅
     - userFills   → _publish_fill_events()          → OrderFilledEvent(source="trading")   → EventBus → WebSocketOrderManager 订阅
     - user        → _publish_user_events()          → PositionUpdatedEvent / BalanceChangedEvent(source="trading") → EventBus → Executor 过滤后处理

Trading WS 不注册任何 message 回调（不调用 add_message_callback），仅依赖 _cache_latest_data 发布事件。

EventBus 订阅顺序保证：Executor 与 WebSocketOrderManager 的 _subscribe_events() 均在 __init__ 阶段调用（先于 start()），而 Trading WS daemon 线程在 start() 中才启动并建立网络连接，故订阅必然先于第一条消息到达。此顺序由代码结构强制保证，无需额外缓冲或回放逻辑。若未来调整初始化顺序，需重新评估此假设。

3.3 事件发布全景

3.4 重连

Trading WS 重连 → WebSocketReconnectedEvent(source="trading")
  → Executor._on_websocket_reconnected() 仅当 source=="trading" 时执行 → 触发 verify_pending_orders ✅

Market WS 重连 → WebSocketReconnectedEvent(source="market")
  → Executor._on_websocket_reconnected() 因 source≠"trading" 直接 return，不触发订单补查 ✅

3.5 半连接降级

4. 模块级设计

5. 文件级实现规格

实现时以方法名与下文契约/删除清单为准；行号仅作参考，若与当前代码不一致则以契约为准。

5.1 src/config.py

import os
import logging

# ---------- 行情 WebSocket（主网固定） ----------
WS_MARKET_URL = "wss://api.hyperliquid.xyz/ws"

# ---------- 交易 WebSocket（随 TRADING_NETWORK） ----------
_trading_network = os.getenv("TRADING_NETWORK", "mainnet").lower()
if _trading_network not in ("mainnet", "testnet"):
    logging.getLogger(__name__).warning(
        "TRADING_NETWORK=%s 非法，回退为 mainnet", os.getenv("TRADING_NETWORK")
    )
    _trading_network = "mainnet"

WS_TRADING_URL = os.getenv("WS_TRADING_URL") or (
    "wss://api.hyperliquid-testnet.xyz/ws"
    if _trading_network == "testnet"
    else "wss://api.hyperliquid.xyz/ws"
)

删除清单：删除 WS_URL；所有对 WS_URL 的引用改为 WS_MARKET_URL 并删除原变量。

5.2 src/utils/websocket/enhanced_ws_manager.py

契约：ws_url 与 source_name 为必选参数，无默认值；事件 source 仅使用 self._source_name，合法取值仅 "market"、"trading"；实现后全局禁止出现 source="websocket"。

5.2.1 构造函数

def __init__(
    self,
    subscriptions: List[Dict],
    ws_url: str,           # 必选，无默认值；位于可选参数之前避免语法错误
    source_name: str,      # 必选，取值仅 "market" 或 "trading"
    on_state_change: Optional[Callable] = None,
    timeout: int = WS_TIMEOUT,
    skip_disconnects: bool = False,
    alert_callback: Optional[Callable] = None,
    max_retries: int | None = WS_MAX_RETRIES,
    alert_threshold: int = WS_ALERT_THRESHOLD,
):
    assert source_name in ("market", "trading"), (
        f"source_name 非法: {source_name!r}，仅允许 'market' 或 'trading'"
    )
    self.ws_url = ws_url
    self._source_name = source_name

注意：ws_url 与 source_name 必须置于所有可选参数之前。Python 不允许无默认值的位置参数出现在有默认值参数之后（会触发 SyntaxError）。调用侧统一使用关键字传参（见 5.3.5），不受顺序影响。

5.2.2 事件发布

所有 _event_bus.publish(...) 中的 source= 使用 source=self._source_name（共约 9 处：_on_open 两处、_on_close/_on_error 一处、_publish_candle_event、_publish_orderbook_event、_publish_price_event、_publish_user_events 内多处、_publish_order_status_events、_publish_fill_events）。

删除清单：实现后全局搜索 source="websocket"，确保结果为零。同步修改 src/events/base.py 中 Event 的 source 字段 docstring，仅保留「仅允许 market（行情 WS）或 trading（交易 WS）」，删除 websocket/http/internal 等旧语义。

5.3 src/services/realtime_kline_service_base.py

顶层导入

from src.config import WS_MARKET_URL, WS_TRADING_URL

5.3.1 属性初始化（__init__）

self.ws_trading_manager: Optional[EnhancedWebSocketManager] = None
self._trading_ws_thread: Optional[threading.Thread] = None

5.3.2 _build_subscriptions()

• 契约：仅返回 candle + l2Book 的订阅列表。
• 删除清单：不得包含 orderUpdates、userFills、user 的订阅构建；不得包含对 _executor/_wallet 的访问；不得使用 hasattr(..., '_executor') 或 getattr(..., '_executor', None)。

5.3.3 _build_trading_subscriptions()

def _build_trading_subscriptions(self) -> List[Dict]:
    """构建交易 WS 订阅列表（orderUpdates / userFills / user）。无可用地址时返回空列表。"""
    if not self._trading_orchestrator:
        return []
    user_address = self._trading_orchestrator.get_trading_ws_user_address()
    if not user_address:
        return []
    return [
        {"type": "orderUpdates", "user": user_address},
        {"type": "userFills",    "user": user_address},
        {"type": "user",         "user": user_address},
    ]

5.3.4 订阅初始化（__init__）

self.subscriptions = self._build_subscriptions()
self.trading_subscriptions = self._build_trading_subscriptions()

5.3.5 _init_service_threads()

创建两个 manager 时均显式传入 ws_url 与 source_name：

def _init_service_threads(self):
    # 行情 WS（主网固定，source="market"）
    self.ws_manager = EnhancedWebSocketManager(
        subscriptions=self.subscriptions,
        on_state_change=self.on_state_change,
        timeout=WS_TIMEOUT,
        alert_callback=self._send_system_alert,
        max_retries=WS_MAX_RETRIES,
        alert_threshold=WS_ALERT_THRESHOLD,
        ws_url=WS_MARKET_URL,
        source_name="market",
    )
    self.ws_manager.add_message_callback(self.on_message)
    _set_market_ws_manager(self.ws_manager)

    if self.trading_subscriptions:
        self.ws_trading_manager = EnhancedWebSocketManager(
            subscriptions=self.trading_subscriptions,
            on_state_change=self._on_trading_state_change,
            timeout=WS_TIMEOUT,
            alert_callback=self._send_trading_alert,
            max_retries=WS_MAX_RETRIES,
            alert_threshold=WS_ALERT_THRESHOLD,
            ws_url=WS_TRADING_URL,
            source_name="trading",
        )
        # 不注册 message 回调：订单/用户数据仅由 _cache_latest_data 发布到 EventBus
        self.logger.info(
            f"🌐 WS 连接配置 | 行情: {WS_MARKET_URL} (主网固定)"
            f" | 交易: {WS_TRADING_URL} (TRADING_NETWORK={os.getenv('TRADING_NETWORK','mainnet')})"
        )
    else:
        self.logger.info("交易订阅为空，仅启动行情 WS")

约定：仅当 self.trading_subscriptions 非空时创建并启动交易 WS；不存在空订阅的 trading manager 或占位线程。

5.3.6 Trading WS 状态与告警

def _on_trading_state_change(self, state: str, info: Optional[str] = None):
    self.logger.info(f"[交易WS] 状态变化: {state}" + (f" | {info}" if info else ""))

def _send_trading_alert(self, title: str, content: str):
    self._send_system_alert(f"[交易WS] {title}", content)

5.3.7 on_message(msg)

• 契约：仅处理行情（去重 → K 线解析 → 入队）。
• 删除清单：不得包含 channel in ("orderUpdates", "userFills", "user") 的判断；不得包含订单缓冲区写入/回放；不得调用 WebSocketOrderManager 或任何「订单原始消息」处理。

def on_message(self, msg: Dict):
    if self._message_dedup.is_duplicate(msg):
        return
    kline = self._parse_kline(msg)
    if not kline:
        return
    self.kline_buffer.put_nowait(kline)
    # ... 后续仅与 K 线入队、分析入队相关，无 orderUpdates/userFills/user 分支

5.3.8 生命周期管理

start()：先启动交易 WS 线程（若存在），再阻塞于行情 WS。

def start(self):
    # 原有工作线程启动
    if self.ws_trading_manager is not None:
        self._trading_ws_thread = threading.Thread(
            target=self.ws_trading_manager.start,
            daemon=True,
            name="trading-ws",
        )
        self._trading_ws_thread.start()
    self.ws_manager.start()

stop()：先停 orchestrator → 交易 WS（含 join）→ 行情 WS。

def stop(self):
    if self._trading_orchestrator:
        self._trading_orchestrator.stop()
    if self.ws_trading_manager is not None:
        self.ws_trading_manager.stop()
        if self._trading_ws_thread is not None and self._trading_ws_thread.is_alive():
            self._trading_ws_thread.join(timeout=5)
            if self._trading_ws_thread.is_alive():
                self.logger.warning("交易 WS 线程在 5s 内未退出")
    self.ws_manager.stop()
    # ... 其余等待队列清空等

5.3.9 动态订阅（新币种）

add_subscriptions 仅对 self.ws_manager 调用（只加 candle/l2Book），不涉及交易 WS。

5.4 src/trading/orchestrator.py

新增方法，供 RealtimeKlineServiceBase 构建交易 WS 订阅时调用：

def get_trading_ws_user_address(self) -> Optional[str]:
    """返回交易 WS 订阅所需的 user 地址；无 executor 或 wallet 时返回 None。"""
    if self._executor is None:
        return None
    wallet = getattr(self._executor, "_wallet", None)
    if wallet is None:
        return None
    return wallet.address

约束：RealtimeKlineServiceBase 不得直接访问 Orchestrator 的 _executor 或 _wallet，仅通过此接口获取地址。直接访问 self._executor._wallet.address 在 _wallet 为 None 时会抛 AttributeError，故改用 getattr 防御。

5.5 src/trading/executor.py

三个事件 handler 入口增加 source 过滤，仅处理 source="trading"：

def _on_position_updated(self, event: PositionUpdatedEvent):
    if event.source != "trading":
        return
    # ... 原有逻辑不变 ...

def _on_balance_changed(self, event: BalanceChangedEvent):
    if event.source != "trading":
        return
    # ... 原有逻辑不变 ...

def _on_websocket_reconnected(self, event: WebSocketReconnectedEvent):
    if event.source != "trading":
        return
    # ... 原有逻辑不变 ...

5.6 全局行情 WS 获取（原 get_global_ws_manager）

将 get_global_ws_manager / _set_global_ws_manager 重命名为 get_market_ws_manager / _set_market_ws_manager，所有调用处同步更新。语义为「行情 WS（主网）」；禁止将返回值用于交易相关逻辑。

6. 初始化时序

__init__
  ├── _init_trading_module()             → TradingOrchestrator + Executor，Executor._subscribe_events() 订阅 EventBus
  ├── self.ws_trading_manager = None
  ├── self._trading_ws_thread = None
  ├── _build_subscriptions()            → 仅 candle + l2Book
  ├── _build_trading_subscriptions()    → 仅当 get_trading_ws_user_address() 返回地址时非空
  └── _init_service_threads()
            ├── ws_manager(ws_url=WS_MARKET_URL, source_name="market")
            └── ws_trading_manager(ws_url=WS_TRADING_URL, source_name="trading")  [仅当 trading_subscriptions 非空]

start()
  ├── 工作线程启动
  ├── ws_trading_manager.start()  [daemon 线程，若存在]
  └── ws_manager.start()          [阻塞主线程]

stop()
  ├── _trading_orchestrator.stop()
  ├── ws_trading_manager.stop() + _trading_ws_thread.join(timeout=5)
  └── ws_manager.stop()

7. 边界与注意事项

• 消息去重：on_message 的 MessageDeduplicator 仅作用于行情。Trading WS 无 message 回调，WebSocketOrderManager 内部有 oid 级去重。
• 并发与阻塞：EnhancedWebSocketManager.start() 为阻塞调用，故交易 WS 必须在独立 daemon 线程启动。stop() 中先停交易 WS 并 join(timeout=5)，再停行情 WS，避免竞态。
• 连接失败：Trading WS 连接失败与现有重试与飞书告警一致，不阻塞行情 WS；订单依赖 HTTP 兜底。
• mainnet=mainnet：TRADING_NETWORK=mainnet 时两 URL 相同，但仍维持两条独立的 WebSocket 连接（各自心跳、各自重连）。这是有意的设计选择：代码路径统一，行情/交易订阅隔离，测试/mainnet 行为一致。代价是多一条长连接，对服务端影响可忽略不计。
• 监控：market_ws_state 来自 on_state_change；trading_ws_state 来自 _on_trading_state_change（带 [交易WS] 前缀）；trading_ws_thread_alive 可在 stop() 的 join 超时处打 warning。两个 WS 共用同一套 WS_ALERT_THRESHOLD（连续断连次数阈值）和 WS_MAX_RETRIES 配置；_send_trading_alert 仅在标题前缀加 [交易WS] 以便在飞书消息中区分来源，告警触发逻辑与行情 WS 一致。
• 事件基类：src/events/base.py 中 Event 的 source 字段 docstring 仅保留「仅允许 market（行情 WS）或 trading（交易 WS）」，删除 websocket/http/internal 等旧语义。
• userFills 与 user.fills：两者均来自 Trading WS，但订阅者不同、职责不同，不存在重复处理。
  • userFills 频道 → _publish_fill_events() → OrderFilledEvent → WebSocketOrderManager 订阅（更新订单状态机，以 oid 为去重键，重复消息安全幂等）。
  • user 频道的 fills 字段 → _publish_user_events() → OrderFilledEvent → Executor 订阅（刷新持仓/余额缓存）。
  • 两路事件的消费者不同，不会造成同一逻辑的重复执行。WebSocketOrderManager 不订阅 user.fills 路径，Executor 不订阅 userFills 路径。

8. 改动量汇总

实现后禁止符号（grep 零结果）

9. 测试验证清单

功能测试

单元测试

压力/并发