系统架构设计文档（更新版）

1. 文档信息

文档标题：交易系统架构重新设计
版本：1.4
创建日期：2025-10-01
更新日期：2025-10-02（新增：基于WebSocket的订单生命周期管理，自动取消超时未成交订单）
作者：Grok 4 (基于用户描述生成)
目的：基于现有项目描述和更新要求，重新设计系统架构，使其更模块化、可扩展、安全，并形成清晰的文档。现有系统涉及两个账户成组，通过交易策略组件生成信号，信号基于市场数据和个人仓位数据决定交易对冲。新更新：账户数据获取和下单执行均通过WebSocket（WS）实现，并带授权（auth）机制；集成Pacifica WS API（https://docs.pacifica.fi/api-documentation/api/websocket）；使用TypeScript实现；添加认证细节（基于Python sample，翻译为TypeScript逻辑）。

2. 系统概述

2.1 系统背景

现有系统是一个交易系统，核心是两个账户（Account A 和 Account B）成组协作。交易策略组件负责生成交易信号，包括：

平衡仓位信号：用于调整两个账户间的仓位平衡。
减仓信号：用于减少持仓以降低风险。
开仓信号：用于开启新仓位。

信号生成依赖于：

市场数据：实时价格（Price）和订单簿（Orderbook），通过WebSocket（WS）订阅获取，无需额外授权。基于Pacifica WS API，使用公共通道订阅。
个人仓位数据：订单（Orders）、账户余额（Account Balance）和账户仓位（Account Position），通过带授权的WebSocket实现实时订阅和更新。认证使用私钥签名机制（Ed25519基58编码），生成签名header和payload。

基于这些数据，系统决定是否开启交易对冲（Hedging），以实现风险管理和利润优化。下单执行也通过带授权的WebSocket实现，确保实时性和安全性。所有WS交互遵循Pacifica API规范，包括心跳机制（ping/pong，每60秒）以维持连接。认证示例（基于提供的Python sample）展示如何为私有操作（如取消订单）生成签名消息，可扩展到订阅账户数据和下单。

认证机制概述（基于sample）：

使用私钥（base58编码）生成Keypair，提取public_key作为account。
构建signature_header（timestamp、expiry_window、type）。
构建signature_payload（操作特定参数，如all_symbols for cancel_all_orders）。
使用sign_message生成message和signature。
组合request_header（account、signature、timestamp、expiry_window）和payload形成message_to_send。
WS消息格式：{"id": uuid, "params": {operation: message_to_send}}。
连接使用WSS，支持ping_interval=30（TypeScript中可配置）。

注意：Python sample为参考；在TypeScript中，使用库如@solana/web3.js或tweetnacl实现Ed25519签名和base58解码。后续需确认Pacifica的精确type值（如"subscribe_account" for 账户订阅）。

2.2 设计目标

模块化：将系统拆分为独立组件，便于维护和扩展。
实时性：所有数据获取和执行均支持实时WS推送，减少轮询延迟。
安全性：WS连接带授权（私钥签名），数据加密传输。签名包含expiry_window防重放攻击。
可扩展性：易于添加更多账户组或新信号类型。认证模块可复用。
效率：最小化延迟，确保数据流畅通。集成心跳以防连接超时（24小时重连）。

2.3 假设与约束

系统运行在Node.js/TypeScript环境中，支持WebSocket。
Pacifica WS端点：Mainnet wss://ws.pacifica.fi/ws，Testnet wss://test-ws.pacifica.fi/ws。
账户数据和下单需通过带授权的WS连接（签名认证，无需query/header token）。
无需处理高频交易（HFT），但支持中频交易。
外部依赖：Pacifica WS API；TypeScript库：ws (WebSocket)、tweetnacl (签名)、bs58 (base58)。

3. 系统架构

3.1 高层架构图（文本描述）

系统采用分层架构：

[外部数据源: Pacifica WS API]
  - 市场数据 (WS: Price/Orderbook，无auth)
  - 账户数据 (WS: Orders/Balance/Position，带签名auth)
  - 下单执行 (WS: Send Orders，带签名auth)

↓ (数据采集层)

[数据采集组件]
  - Market Data Fetcher (WS，无auth)
  - Account Data Fetcher (WS，带签名auth)

↓ (数据流: 实时推送)

[核心处理层]
  - Data Aggregator (聚合市场与账户数据)
  - Trading Strategy Engine (生成信号: 平衡/减仓/开仓)
  - Hedging Decision Module (决定对冲)

↓ (信号输出)

[执行层]
  - Signal Executor (通过WS下单，带签名auth)
  - Logger & Monitor (日志与监控)

↓ (反馈循环)

[账户组: Account A & B]

数据流：单向从数据源到执行层，但有反馈循环（如执行后通过WS更新账户数据）。所有WS消息使用JSON格式，如{"id": "uuid", "params": {...}}。私有操作需签名。
技术栈建议：Node.js/TypeScript (ws库 for WS), Redis (实时数据缓存), SQL/NoSQL (持久化日志)。

3.2 主要组件

以下表格列出系统主要组件、职责、输入/输出及依赖。更新点：集成签名认证模块；所有私有WS操作使用TypeScript等效逻辑。

组件名称	职责描述	输入数据	输出数据	依赖/技术
Market Data Fetcher	通过WebSocket订阅实时市场数据（公共通道），确保无授权访问。处理断线重连和心跳（ping每60秒）。	WS URL (e.g., wss://ws.pacifica.fi/ws)	实时Price/Orderbook JSON	TypeScript + ws库；消息: {"method": "subscribe", "params": {channel: "market"}}
Account Data Fetcher	通过带签名的WebSocket订阅两个账户的个人数据（私有通道）。实时接收更新，支持账户组配置。处理签名生成、token刷新（expiry_window）、断线重连和心跳。	WS URL + Private Key (base58)	Orders/Balance/Position JSON	TypeScript + ws库 + tweetnacl/bs58；签名: signMessage(header, payload, keypair)
Data Aggregator	聚合市场和账户数据，进行初步清洗和同步。缓存最近数据以减少延迟。	来自Fetcher的实时数据	聚合数据集 (e.g., {'market': {...}, 'accounts': {...}})	TypeScript；Redis/Memory Cache
Trading Strategy Engine	根据聚合数据运行策略算法，生成信号。支持自定义规则（如阈值触发）。	聚合数据集	信号列表 (e.g., [{'type': 'open', 'account': 'A', 'details': {...}}])	TypeScript + 自定义算法 (e.g., lodash for analysis)
Hedging Decision Module	评估信号是否需对冲（e.g., 如果A开仓，B减仓）。基于风险模型决定。	生成的信号 + 聚合数据	对冲决策 (e.g., {'hedge': True, 'actions': [...]})	TypeScript；规则引擎/Risk Model
Signal Executor	通过带签名的WebSocket执行信号/对冲，向交易所发送订单。处理执行失败重试和确认。	信号 + 对冲决策 + WS URL + Private Key	执行结果 (成功/失败日志)	TypeScript + ws库 + tweetnacl/bs58；消息: {"id": "uuid", "params": {order: signedMessage}}
Logger & Monitor	记录所有操作、信号和错误。监控系统健康（如数据延迟、WS连接状态、心跳响应、签名有效性）。	全系统事件	日志文件/警报	TypeScript + Winston库；Prometheus
Auth Signer (新)	通用签名模块：生成Keypair、signature_header/payload、message/signature。复用于私有WS操作。	Private Key + operation type + params	Signed message_to_send	TypeScript + tweetnacl (Ed25519) + bs58；等效Python sign_message
Order Lifecycle Manager (新)	基于WebSocket实时监控订单生命周期，追踪未成交订单的存活时间，自动取消超时订单。支持配置超时阈值、检查间隔和重试策略。	WebSocket订单更新 + 配置参数 (maxOrderAge, checkInterval)	订单取消信号 (Cancel Signal)	TypeScript + 定时器 + Map缓存；集成 Account Data Fetcher 和 Signal Executor

3.3 数据流

采集阶段：Market Data Fetcher 通过WS（无auth）发送{"method": "subscribe", "params": {...}}订阅公共市场数据。Account Data Fetcher 通过WS（带签名）订阅私有账户数据：使用Auth Signer生成签名消息，发送{"id": "uuid", "params": {"subscribe_account": signedPayload}}。
聚合阶段：Data Aggregator 合并数据，确保时间同步（e.g., 使用时间戳对齐）。
策略阶段：Trading Strategy Engine 每Y秒/事件触发运行算法：
- 计算仓位差异 → 生成平衡信号。
- 检测风险阈值 → 生成减仓信号。
- 识别机会 → 生成开仓信号。
决策阶段：Hedging Decision Module 检查信号间冲突，决定对冲（e.g., A开仓时B平衡）。
执行阶段：Signal Executor 通过WS（带签名）发送订单消息（使用Auth Signer），并实时接收执行确认。
反馈阶段：执行后，通过Account Data Fetcher的WS更新数据，形成闭环。定期发送{"method": "ping"}维持连接，响应{"channel": "pong"}。签名expiry_window=5000ms，确保及时性。
订单生命周期管理阶段（新）：Order Lifecycle Manager 监听 Account Data Fetcher 推送的订单状态更新（通过WS实时获取）：
- 当接收到订单状态更新时，追踪订单创建时间（created_at）和当前状态（open/filled/cancelled）。
- 维护未成交订单缓存（Map），记录订单ID、交易对、创建时间、检查次数。
- 定期检查（每5秒，可配置lifecycleCheckInterval）所有未成交订单的存活时间。
- 当订单存活时间超过配置阈值（默认30秒，可配置maxOrderAge）时，生成订单取消信号。
- 取消信号传递给 Signal Executor，通过WS（带签名）发送取消订单请求：{"id": uuid(), "params": {"cancel_order": signedMessage}}。
- 取消失败时自动重试（最多3次，可配置cancelRetryAttempts），每次重试间隔1秒（可配置cancelRetryDelay）。
- 取消成功/失败均记录到 Logger & Monitor，并从缓存中移除已处理订单。

3.4 信号类型定义

平衡仓位信号：当两个账户仓位差 > Z% 时触发。示例：{'type': 'balance', 'from': 'A', 'to': 'B', 'amount': 100}。执行时签名type="balance_position"。
减仓信号：当市场波动 > W% 或仓位 > V% 时触发。示例：{'type': 'reduce', 'account': 'A', 'percent': 50}。执行时签名type="reduce_position"。
开仓信号：当价格趋势符合策略时触发。示例：{'type': 'open', 'account': 'B', 'symbol': 'BTC/USDT', 'side': 'buy', 'price': 117680, 'amount': 0.001, 'order_type': 'limit'}。执行时签名type="place_order"。订单类型选择（可配置）：系统支持 limit（限价单）和 market（市价单）两种订单类型，通过配置参数 preferredOrderType 选择（默认 'limit'）。限价单价格策略（穿越价差快速成交）：为保证刷量交易的快速成交，采用接近对手价的定价策略。买单（bid）使用 orderbook 最优卖价（best_ask）作为基准并略微降低，卖单（ask）使用最优买价（best_bid）作为基准并略微提高。这样订单价格会非常接近当前成交区域，确保快速成交。价格计算公式：bid_price = orderbook.best_ask * (1 - priceBuffer), ask_price = orderbook.best_bid * (1 + priceBuffer)，其中 priceBuffer 为价格缓冲（默认0.0001=0.01%），用于避免完全穿越价差变成纯taker订单。市价单策略：当配置为 market 时，直接使用市价单成交，无需计算价格，成交速度最快但支付 taker 费用。可通过配置参数 emergencyMarketThreshold 设置紧急市价单阈值，当限价单超时或价格波动超过阈值时自动切换为市价单。
取消订单信号（新）：当订单生命周期超过配置阈值（maxOrderAge）时由 Order Lifecycle Manager 自动触发。示例：{'type': 'cancel_order', 'order_id': 12345, 'symbol': 'BTC', 'reason': 'timeout', 'age': 35.2}。执行时签名type="cancel_order"，参数包含order_id和symbol。

4. 实现考虑

4.1 技术选型

语言：TypeScript (Node.js runtime)。
框架：Express/Fastify (API接口，如果需外部控制)、Bull (任务队列，如果需分布式)。
数据库：Redis (实时缓存)、PostgreSQL (历史数据)。
部署：Docker容器化，Kubernetes orchestration for scalability。
WS实现：使用ws库，支持WSS。订阅格式：{"method": "subscribe", "params": {channel: "name"}}；私有操作：{"id": "uuid", "params": {type: signedMessage}}。心跳：setInterval发送ping。

认证TypeScript等效（基于Python sample）：

import nacl from 'tweetnacl';
import bs58 from 'bs58';
import { v4 as uuidv4 } from 'uuid';
import WebSocket from 'ws'; // 或 ws 库

// 生成Keypair (假设Ed25519)
const privateKeyBytes = bs58.decode(PRIVATE_KEY);
const keypair = nacl.sign.keyPair.fromSecretKey(privateKeyBytes);
const publicKey = bs58.encode(keypair.publicKey);

// 签名函数 (等效 sign_message)
function signMessage(header: any, payload: any, keypair: any): [string, string] {
const message = JSON.stringify({ header, payload });
const messageBytes = new TextEncoder().encode(message);
const signatureBytes = nacl.sign.detached(messageBytes, keypair.secretKey);
const signature = bs58.encode(signatureBytes);
return [message, signature];
}

// 示例: 取消订单 (泛化到其他操作)
async function sendSignedWS(WS_URL: string, operationType: string, payload: any, privateKey: string) {
const timestamp = Math.floor(Date.now());
const signatureHeader = { timestamp, expiry_window: 5000, type: operationType };
const [message, signature] = signMessage(signatureHeader, payload, keypair);
const requestHeader = { account: publicKey, signature, timestamp: signatureHeader.timestamp, expiry_window: signatureHeader.expiry_window };
const messageToSend = { ...requestHeader, ...payload };

const ws = new WebSocket(WS_URL, { pingInterval: 30000 }); // 30s ping
ws.on('open', async () => {
  const wsMessage = { id: uuidv4(), params: { [operationType]: messageToSend } };
  ws.send(JSON.stringify(wsMessage));
});
ws.on('message', (data) => { console.log('Response:', data.toString()); });
// 处理 close/error/reconnect
}

扩展：为订阅账户数据，使用type="subscribe_private"；为下单，使用type="place_order"。

订单生命周期管理TypeScript实现（新增）：

import { EventEmitter } from 'events';

// 订单追踪数据结构
interface TrackedOrder {
orderId: number;
symbol: string;
side: 'bid' | 'ask';
createdAt: number;      // timestamp in ms
status: 'open' | 'filled' | 'cancelled';
checkCount: number;     // 检查次数
retryCount: number;     // 取消重试次数
}

// 配置接口
interface LifecycleConfig {
maxOrderAge: number;          // 订单最大存活时间（ms），默认30000
lifecycleCheckInterval: number; // 检查间隔（ms），默认5000
cancelRetryAttempts: number;   // 取消重试次数，默认3
cancelRetryDelay: number;      // 重试延迟（ms），默认1000
}

// 订单生命周期管理器
class OrderLifecycleManager extends EventEmitter {
private orders: Map<number, TrackedOrder> = new Map();
private checkTimer: NodeJS.Timeout | null = null;
private config: LifecycleConfig;

constructor(config: Partial<LifecycleConfig> = {}) {
  super();
  this.config = {
    maxOrderAge: config.maxOrderAge || 30000,
    lifecycleCheckInterval: config.lifecycleCheckInterval || 5000,
    cancelRetryAttempts: config.cancelRetryAttempts || 3,
    cancelRetryDelay: config.cancelRetryDelay || 1000
  };
}

// 启动生命周期监控
start(): void {
  if (this.checkTimer) return;
  this.checkTimer = setInterval(() => {
    this.checkAndCancelStaleOrders();
  }, this.config.lifecycleCheckInterval);
  console.log('Order lifecycle manager started');
}

// 停止监控
stop(): void {
  if (this.checkTimer) {
    clearInterval(this.checkTimer);
    this.checkTimer = null;
  }
  console.log('Order lifecycle manager stopped');
}

// 监听订单更新（从 WebSocket Account Data Fetcher）
onOrderUpdate(order: any): void {
  const orderId = order.order_id || order.i;
  const status = order.order_status || order.status;

  if (status === 'open') {
    // 新订单或未成交订单，添加到追踪
    if (!this.orders.has(orderId)) {
      this.orders.set(orderId, {
        orderId,
        symbol: order.symbol || order.s,
        side: order.side,
        createdAt: (order.created_at || order.t) * 1000, // convert to ms
        status: 'open',
        checkCount: 0,
        retryCount: 0
      });
      console.log(`Tracking new order: ${orderId} (${order.symbol})`);
    }
  } else {
    // 已成交或已取消，从追踪中移除
    if (this.orders.has(orderId)) {
      this.orders.delete(orderId);
      console.log(`Order ${orderId} removed from tracking (status: ${status})`);
    }
  }
}

// 定期检查并取消超时订单
private async checkAndCancelStaleOrders(): Promise<void> {
  const now = Date.now();
  const staleOrders: TrackedOrder[] = [];

  for (const [orderId, tracked] of this.orders) {
    tracked.checkCount++;
    const age = now - tracked.createdAt;

    if (age > this.config.maxOrderAge) {
      staleOrders.push(tracked);
      console.warn(`Order ${orderId} has exceeded max age: ${age}ms (limit: ${this.config.maxOrderAge}ms)`);
    }
  }

  // 批量取消超时订单
  for (const order of staleOrders) {
    await this.cancelOrderWithRetry(order);
  }
}

// 带重试的订单取消
private async cancelOrderWithRetry(order: TrackedOrder): Promise<void> {
  const maxRetries = this.config.cancelRetryAttempts;

  while (order.retryCount < maxRetries) {
    try {
      // 发出取消信号（由 Signal Executor 处理）
      const cancelSignal = {
        type: 'cancel_order',
        order_id: order.orderId,
        symbol: order.symbol,
        reason: 'timeout',
        age: (Date.now() - order.createdAt) / 1000 // 秒
      };

      this.emit('cancel_signal', cancelSignal);
      console.log(`Cancel signal emitted for order ${order.orderId} (attempt ${order.retryCount + 1}/${maxRetries})`);

      // 等待确认（假设有确认机制）
      // 如果成功，从追踪中移除
      this.orders.delete(order.orderId);
      return;

    } catch (error) {
      order.retryCount++;
      console.error(`Failed to cancel order ${order.orderId} (attempt ${order.retryCount}/${maxRetries}):`, error);

      if (order.retryCount < maxRetries) {
        await this.delay(this.config.cancelRetryDelay);
      } else {
        // 达到最大重试次数，记录错误并移除
        console.error(`Max retry attempts reached for order ${order.orderId}, giving up`);
        this.emit('cancel_failed', {
          orderId: order.orderId,
          symbol: order.symbol,
          error: 'Max retries exceeded'
        });
        this.orders.delete(order.orderId);
      }
    }
  }
}

// 延迟工具函数
private delay(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// 获取当前追踪的订单数量
getTrackedOrderCount(): number {
  return this.orders.size;
}

// 清理所有追踪的订单
clear(): void {
  this.orders.clear();
}
}

// 使用示例
const lifecycleManager = new OrderLifecycleManager({
maxOrderAge: 30000,      // 30秒
lifecycleCheckInterval: 5000, // 每5秒检查一次
cancelRetryAttempts: 3,
cancelRetryDelay: 1000
});

// 监听取消信号
lifecycleManager.on('cancel_signal', (signal) => {
// 传递给 Signal Executor 执行取消
console.log('Executing cancel signal:', signal);
// signalExecutor.execute(signal);
});

// 监听取消失败事件
lifecycleManager.on('cancel_failed', (info) => {
console.error('Order cancellation failed:', info);
// 记录到日志或告警系统
});

// 启动监控
lifecycleManager.start();

// 接收 WebSocket 订单更新
// accountDataFetcher.on('order_update', (order) => {
//   lifecycleManager.onOrderUpdate(order);
// });

4.2 安全与风险

数据安全：WS连接使用WSS (SSL)，私钥环境变量存储。签名防篡改/重放（timestamp + expiry_window）。
错误处理：每个WS组件有error事件监听，失败时重连并警报。签名无效时重试生成。
测试：单元测试签名函数（Jest，验证message/signature）、集成测试WS数据流（模拟订阅）、回测历史数据。模拟WS断线、签名过期场景。
风险：WS连接不稳定 → 实现心跳检测和自动重连；私钥泄露 → 使用HSM或环境加密。文档缺失type细节 → 建议API测试确认。
订单生命周期管理风险（新增）：
- 订单堆积风险：未成交订单过多会占用账户资金和保证金。通过 Order Lifecycle Manager 自动取消超时订单（默认30秒），防止资金长时间锁定。
- 取消失败处理：取消请求失败时自动重试（最多3次），失败后记录到 Logger & Monitor 并触发告警。建议设置告警阈值（如连续5次取消失败）触发人工介入。
- 时钟同步：订单生命周期依赖系统时钟，需确保服务器时钟准确（使用NTP同步）。时钟偏差可能导致误判订单超时。
- 市场波动影响：在极端行情下，限价单可能长时间未成交属于正常现象。建议根据市场条件动态调整 maxOrderAge 参数（如高波动时延长至60秒）。
- 取消延迟：从检测超时到取消确认存在延迟（网络 + API处理），期间订单可能成交。需处理"取消失败-订单已成交"的情况，避免重复取消。
- 监控指标：建议监控订单平均存活时间、取消成功率、取消重试率等指标，及时发现异常。

4.3 扩展点

添加更多账户组：配置化Account Data Fetcher的WS订阅和私钥。
新信号类型：扩展Trading Strategy Engine的规则引擎，并定义对应签名type。
集成ML：用TensorFlow.js在策略中添加预测模型。

4.4 Delta中性刷量策略优化

说明：以下优化专门针对Delta中性刷量交易策略，旨在提高成交效率、降低风险、优化手续费成本。

4.4.1 双账户协同机制

同步下单（Synchronized Order Placement）：
- 确保Account A和Account B的买卖单在同一时间窗口（< 100ms）内发出
- 使用Promise.all()并行发送两个账户的订单，减少单边暴露风险
- 配置参数：syncOrderDelay（默认50ms），控制两单之间的最大时间差
交叉成交预防（Self-Trade Prevention）：
- 检测两个账户订单价格是否可能相交（买价≥卖价）
- 实施最小价差规则：minPriceGap（默认0.01%），防止自成交
- 使用唯一的client_order_id前缀区分不同账户的订单
动态主从切换（Dynamic Master-Slave Switching）：
- 根据实时余额选择主账户：余额多的账户优先开仓
- 考虑手续费率差异：优先使用VIP等级高（费率低）的账户
- 每次交易前重新评估，实现动态负载均衡

4.4.2 订单大小优化

基于深度的动态调整（Depth-Based Sizing）：

const depth = orderbook.getDepthAt(targetPrice, side);
const baseSize = calculateBaseSize(balance);
const adjustedSize = baseSize * Math.min(1, depth / (baseSize * 2));

深度充足时使用完整订单大小
深度不足时自动缩小订单，避免大幅滑点

阶梯式拆单（Ladder Order Splitting）：
- 大额订单（> splitThreshold）自动拆分成3-5个小单
- 每个子单价格递进：priceStep（默认0.005%）
- 时间间隔发送：splitDelay（默认200ms）
订单大小随机化（Size Randomization）：
```
const randomFactor = 0.8 + Math.random() * 0.4; // 80%-120%
const finalSize = baseSize * randomFactor;
```
- 避免固定大小暴露机器人特征
- 配置参数：orderSizeRandomRange（默认±20%）

4.4.3 时机选择优化

基于波动率的动态间隔（Volatility-Based Intervals）：

const volatility = calculateVolatility(priceHistory, 60); // 60秒窗口
const baseInterval = 5000; // 5秒基础间隔
const dynamicInterval = baseInterval * (1 - volatility * 0.5);

高波动时增加交易频率，低波动时降低
配置参数：volatilityMultiplier（默认0.5）

避开高频时段（Avoid Peak Hours）：
- 跳过整点前后30秒（XX:59:30 - XX:00:30）
- 这些时段通常有大量程序化交易，竞争激烈
- 配置参数：skipPeakHours（默认true）
基于价差的触发（Spread-Based Trigger）：
```
const spread = (orderbook.ask - orderbook.bid) / orderbook.mid;
if (spread > maxSpreadThreshold) return; // 价差过大时不交易
```
- 只在价差合理时执行交易
- 配置参数：maxSpreadThreshold（默认0.002 = 0.2%）

4.4.4 价格策略优化

动态价格缓冲（Dynamic Price Buffer）：

const baseBuffer = 0.0001; // 0.01%
const spreadFactor = currentSpread / averageSpread;
const dynamicBuffer = baseBuffer * Math.max(0.5, Math.min(2, spreadFactor));

价差大时增加buffer，提高成交概率
价差小时减少buffer，优化成本

队列位置优化（Queue Position Optimization）：
- 不总是用最优价格，sometimes join existing orders
- 检测同价位订单量，选择合适的队列位置
- 配置参数：queuePositionStrategy（'aggressive' | 'passive' | 'adaptive'）
多档挂单（Multi-Level Orders）：
- 同时在2-3个价位挂单，增加成交机会
- 分配比例：50%最优价、30%次优价、20%第三档
- 配置参数：orderLevels（默认2）

4.4.5 Delta控制精细化

分层Delta管理（Multi-Timeframe Delta Control）：

const delta1m = calculateDelta(positions, 60);    // 1分钟Delta
const delta5m = calculateDelta(positions, 300);   // 5分钟Delta
const delta1h = calculateDelta(positions, 3600);  // 1小时Delta

// 综合判断，短期Delta权重更高
const weightedDelta = delta1m * 0.5 + delta5m * 0.3 + delta1h * 0.2;

Delta容忍度动态调整（Dynamic Delta Tolerance）：
- 市场平稳时：严格控制（±0.5%）
- 市场波动时：放松控制（±2%）
- 基于30分钟滚动波动率动态调整
预测性Delta调整（Predictive Delta Adjustment）：
- 分析orderbook不平衡度：(bidVolume - askVolume) / totalVolume
- 预测未来价格方向，提前调整仓位
- 避免被动追单，降低成本

4.4.6 成交后快速处理

立即对冲（Immediate Hedging）：

ws.on('order_filled', async (order) => {
const hedgeOrder = createHedgeOrder(order);
await sendOrderWithinMs(hedgeOrder, 50); // 50ms内发出对冲单
});

一边成交立即在另一边账户补单
目标：暴露时间 < 100ms

成交价差利用（Fill Spread Capture）：
- 记录实际成交价vs预期价格的差异
- 正滑点时可适当增加下一单的buffer
- 负滑点时收紧buffer，提高警惕
连续成交激励（Consecutive Fill Boost）：
- 连续N次成功成交后，可临时增加订单大小10%
- 失败后立即恢复正常大小
- 配置参数：consecutiveFillBonus（默认1.1）

4.4.7 竞争对手识别与避让

做市商模式识别（Market Maker Detection）：

function detectMarketMaker(orderbook) {
// 检测固定大小、固定间隔的订单模式
const patterns = findRepetitivePatterns(orderbook);
return patterns.length > threshold;
}

大单跟随（Large Order Following）：
- 检测到大单（> 平均10倍）时顺势调整
- 大买单时稍微提高卖价，大卖单时稍微降低买价
- 配置参数：largeOrderThreshold（默认10x）
智能避让（Smart Avoidance）：
- 发现类似策略（相近价格、大小）时主动避让
- 随机延迟100-500ms后再下单
- 或选择次优价位，避免直接竞争

4.4.8 手续费优化

Maker比例最大化（Maximize Maker Ratio）：

// 优先使用post-only订单
const order = {
...baseOrder,
postOnly: true, // 如果会成为taker则自动取消
price: adjustPriceForMaker(targetPrice)
};

VIP等级优化（VIP Tier Optimization）：
- 追踪当前交易量和下一VIP等级要求
- 接近升级时可适当增加交易频率
- 月底冲量保级/升级
时段选择（Time-Based Optimization）：
- 如果交易所有Happy Hour（费率优惠时段）
- 集中在优惠时段交易
- 其他时段降低频率

4.4.9 风险事件响应

新闻事件自动检测（News Event Detection）：
- 监控价格突变（> 1%/分钟）
- 检测到异常时自动暂停交易30秒
- 配置参数：priceChangeThreshold（默认0.01）

异常价格快速响应（Anomaly Response）：

if (Math.abs(currentPrice - ma20) / ma20 > 0.05) {
// 价格偏离MA20超过5%
await cancelAllOrders();
await pauseTrading(60000); // 暂停1分钟
}

流动性危机处理（Liquidity Crisis Handling）：
- 当bid-ask spread > 1%时触发
- 立即取消所有订单
- 切换到纯市价单模式快速平仓

4.4.10 刷量效率优化

循环交易优化（Circular Trading）：

// A买B卖 -> B买A卖 循环
async function circularTrade() {
await placeOrders(accountA, 'buy', accountB, 'sell');
await waitForFills();
await placeOrders(accountB, 'buy', accountA, 'sell');
}

形成交易闭环，维持Delta中性
最小化资金占用时间

短期价差收割（Micro Spread Harvesting）：
- 在维持Delta中性的同时捕捉微小价差
- 当捕捉到0.01%以上价差时执行
- 累积小利润，积少成多
滑点容忍度调整（Slippage Tolerance）：
- 刷量模式：接受更大滑点（0.05%）以确保成交
- 盈利模式：严格控制滑点（0.01%）保护利润
- 配置参数：volumeModeSlippage（默认0.0005）

4.4.11 配置参数汇总

```typescript interface DeltaStrategyConfig { // 双账户协同 syncOrderDelay: number; // 同步延迟(ms)，默认50 minPriceGap: number; // 最小价差，默认0.0001

// 订单大小 orderSizeRandomRange: number; // 随机范围，默认0.2 splitThreshold: number; // 拆单阈值，默认1000 USDC

// 时机选择 volatilityMultiplier: number; // 波动率系数，默认0.5 maxSpreadThreshold: number; // 最大价差，默认0.002 skipPeakHours: boolean; // 跳过高峰，默认true

// 价格策略 dynamicPriceBuffer: boolean; // 动态缓冲，默认true queuePositionStrategy: string; // 队列策略，默认'adaptive' orderLevels: number; // 挂单层数，默认2

// Delta控制 deltaTimeframes: number[]; // 时间框架[60,300,3600] deltaWeights: number[]; // 权重[0.5,0.3,0.2]

// 成交处理 immediateHedgeTimeout: number; // 对冲超时(ms)，默认50 consecutiveFillBonus: number; // 连续奖励，默认1.1

// 竞争避让 competitorDetection: boolean; // 竞争检测，默认true largeOrderThreshold: number; // 大单阈值，默认10

// 手续费 preferMakerOrders: boolean; // 优先Maker，默认true postOnlyOrders: boolean; // 仅挂单，默认false

// 风险控制 priceChangeThreshold: number; // 价格突变，默认0.01 liquidityCrisisSpread: number; // 流动性危机，默认0.01

// 刷量优化 volumeModeSlippage: number; // 刷量滑点，默认0.0005 circularTradeEnabled: boolean; // 循环交易，默认true }

5. 附录

术语表：
- WS：WebSocket。
- Auth：Authorization，基于Ed25519私钥签名。
- 对冲：Hedging，通过反向操作降低风险。
- Pacifica WS：端点 wss://ws.pacifica.fi/ws；心跳 ping/pong；签名expiry_window=5000ms。
下一步：建议提供更多Pacifica私有type细节（如subscribe_account payload）、具体策略规则或TypeScript代码反馈以细化实现。测试签名函数与API兼容性。
参考：基于Pacifica WS文档和提供的Python auth sample。如果需要完整TypeScript WS客户端代码或进一步迭代，请提供反馈。

design.md 34 KB Permalink Histórico Raw