> 重要声明：你在上一条中提出“双账户对敲 + 剥头皮”。**对敲/刷量**通常违反多数交易场所的服务条款及所在司法辖区法律/监管要求，属于**市场操纵**范畴。我无法提供任何实现或指导。但我可以提供一份**合规的做市 + 剥头皮（单账户/多 venue、中性、反自成交）**的执行架构与落地方案，帮助你在合规框架下实现高频与中性化目标。下文全部以**合规**为前提：包含自成交预防（STP）、风控守则、合规审计日志等模块。

---

# 目标与约束
- **目标**：在不承担方向性风险的前提下，通过被动做市与微剥头皮提高成交与绩效。
- **约束**：
  - 不与自身账户成交（Self-Trade Prevention，STP）。
  - 遵守各协议和司法辖区的市场行为规则；保留审计日志。
  - 所有策略均以**净敞口≈0**为约束（库存中性），以风控优先。

---

# 系统总览
```
┌───────────────────────────────────────────────────────────────┐
│                           App Runner                          │
│         (DI container, lifecycle, config hot-reload)          │
└───────────────┬───────────────────────────┬────────────────────┘
                │                           │
        ┌───────▼────────┐            ┌─────▼──────────────────────┐
        │  Strategy Bus  │            │  Risk & Compliance Engine │
        │ (MM, Scalper)  │            │  (limits, STP, kill-switch)│
        └───┬─────────────┘            └───────────┬────────────────┘
            │                                       │
     ┌──────▼─────────┐                      ┌──────▼──────────────┐
     │ Order Router   │◄────Health/Latency──►│  Telemetry & Alerts │
     │ (batch, child  │                      └─────────────────────┘
     │  orders)       │
     └───┬────────────┘
         │
  ┌──────▼───────────────┐      ┌──────────────────────────────┐
  │ Exchange Connectors  │◄────►│  Market Data (books,trades)  │
  │ (Venue SDK/REST/WS)  │      │  + Derived Feeds (greeks,VRP)│
  └─────────┬────────────┘      └───────────┬───────────────────┘
            │                                 │
     ┌──────▼───────────┐              ┌──────▼───────────┐
     │ Persistence/DB   │              │ Backtest/Sim     │
     │ (PnL, fills,     │              │ (event-replay)   │
     │  snapshots, logs)│              └──────────────────┘
     └──────────────────┘
```

---

# 模块设计（TypeScript）

## 1. 类型与通用接口
```ts
// domain/types.ts
export type Side = "buy" | "sell";
export type TimeInForce = "GTC" | "IOC" | "FOK";

export interface Order {
  id?: string;
  clientId: string; // unique per venue to support STP
  symbol: string;   // e.g., BTC-PERP
  side: Side;
  px: number;       // limit price
  sz: number;       // base size
  tif: TimeInForce;
  postOnly?: boolean; // passive MM
}

export interface Fill {
  orderId: string;
  tradeId: string;
  px: number;
  sz: number;
  fee: number;
  liquidity: "maker" | "taker";
  ts: number;
}

export interface PositionSnapshot {
  symbol: string;
  base: number; // signed
  quote: number;
  entryPx?: number;
  ts: number;
}

export interface BookLevel { px: number; sz: number; }
export interface OrderBook { bids: BookLevel[]; asks: BookLevel[]; ts: number; }
```

## 2. 交易所连接器（抽象 + 具体实现）
```ts
// connectors/ExchangeAdapter.ts
export interface ExchangeAdapter {
  name(): string;
  // order
  place(o: Order): Promise<{ id: string }>;
  cancel(id: string): Promise<void>;
  amend(id: string, patch: Partial<Order>): Promise<void>;
  // data
  streamOrderBook(symbol: string, onBook: (b: OrderBook) => void): () => void;
  streamTrades(symbol: string, onTrade: (t: Fill) => void): () => void;
  // account
  getPosition(symbol: string): Promise<PositionSnapshot>;
  getFunding(symbol: string): Promise<{ rate: number; ts: number }>;
  // venue features
  supportsSTP(): boolean; // self-trade prevention flag
}
```
> 说明：具体 DEX（如 Drift、Hyperliquid、Aperture 等）各有 SDK，与接口做适配。若无 STP，需在本地实现**自成交预防**：
- 通过 `clientId` + 本地订单簿镜像，避免对冲到自身挂单；
- Router 层做“**cross check**”：下买单前，检查卖一是否为本账户挂单，反之同理。

## 3. 订单路由与子单引擎
```ts
// execution/OrderRouter.ts
import { Order, OrderBook } from "../domain/types";

export interface SlippageGuardCfg { maxBps: number; }

export class OrderRouter {
  constructor(
    private ex: ExchangeAdapter,
    private slip: SlippageGuardCfg,
    private getLocalTop: () => OrderBook | undefined,
  ) {}

  async sendLimitChild(o: Order): Promise<string> {
    const top = this.getLocalTop?.();
    if (top) {
      // basic slippage guard
      const best = o.side === "buy" ? top.asks[0]?.px : top.bids[0]?.px;
      if (best) {
        const bps = Math.abs((o.px - best) / best) * 1e4;
        if (bps > this.slip.maxBps) throw new Error(`slippage > ${this.slip.maxBps} bps`);
      }
    }
    const { id } = await this.ex.place(o);
    return id;
  }
}
```

## 4. 风控与合规
```ts
// risk/RiskEngine.ts
import { PositionSnapshot, Order } from "../domain/types";

export interface RiskLimits {
  maxBaseAbs: number;      // 单品种库存上限
  maxNotionalAbs: number;  // 名义敞口上限
  maxOrderSz: number;      // 单笔下单上限
  killSwitchDrawdown: number; // 当日回撤阈值
}

export class RiskEngine {
  private realizedPnL = 0;

  constructor(private limits: RiskLimits) {}

  checkOrder(o: Order, pos: PositionSnapshot) {
    if (o.sz > this.limits.maxOrderSz) throw new Error("order size too large");
    const nextBase = pos.base + (o.side === "buy" ? o.sz : -o.sz);
    if (Math.abs(nextBase) > this.limits.maxBaseAbs) throw new Error("inventory limit");
  }

  reportFill(pnlDelta: number) {
    this.realizedPnL += pnlDelta;
  }

  shouldHalt(): boolean { return this.realizedPnL < -Math.abs(this.limits.killSwitchDrawdown); }
}
```

## 5. 策略层（做市 + 微剥头皮）
```ts
// strategies/MarketMaker.ts
import { OrderBook, Order } from "../domain/types";
import { OrderRouter } from "../execution/OrderRouter";

export interface MMConfig {
  symbol: string;
  tickSz: number;
  clipSz: number;     // 单笔下单手数
  spreadBps: number;  // 基础点差
  repriceMs: number;  // 重新挂单周期
}

export class MarketMaker {
  private bidId?: string; private askId?: string;
  constructor(private cfg: MMConfig, private router: OrderRouter, private getBook: () => OrderBook | undefined) {}

  onTimer = async () => {
    const book = this.getBook(); if (!book?.bids[0] || !book?.asks[0]) return;
    const mid = (book.bids[0].px + book.asks[0].px) / 2;
    const pxBid = Math.floor(mid * (1 - this.cfg.spreadBps/1e4) / this.cfg.tickSz) * this.cfg.tickSz;
    const pxAsk = Math.ceil (mid * (1 + this.cfg.spreadBps/1e4) / this.cfg.tickSz) * this.cfg.tickSz;
    const baseOrder = ({symbol: this.cfg.symbol, tif: "GTC" as const, postOnly: true, clientId: `mm-${Date.now()}`});
    this.bidId = await this.router.sendLimitChild({...baseOrder, side: "buy",  px: pxBid, sz: this.cfg.clipSz});
    this.askId = await this.router.sendLimitChild({...baseOrder, side: "sell", px: pxAsk, sz: this.cfg.clipSz});
  }
}
```

```ts
// strategies/MicroScalper.ts
import { OrderBook, Order } from "../domain/types";
import { OrderRouter } from "../execution/OrderRouter";

export interface ScalperCfg {
  symbol: string; clipSz: number; takeProfitBps: number; stopBps: number; cooldownMs: number;
}

export class MicroScalper {
  private lastTs = 0;
  constructor(private cfg: ScalperCfg, private router: OrderRouter, private getBook: () => OrderBook | undefined) {}

  onBook(book: OrderBook) {
    const now = Date.now();
    if (now - this.lastTs < this.cfg.cooldownMs) return;
    if (!book.bids[0] || !book.asks[0]) return;

    const spread = (book.asks[0].px - book.bids[0].px) / ((book.asks[0].px + book.bids[0].px)/2) * 1e4;
    // 微剥头皮触发：当点差暂时性放大
    if (spread > 1.2) { // 示例阈值
      this.lastTs = now;
      const buyPx  = book.bids[0].px;
      const sellPx = book.asks[0].px;
      // 方案：在买一吃一点，目标在中点或买一+tp反手平
      const tpPx = buyPx * (1 + this.cfg.takeProfitBps/1e4);
      const slPx = buyPx * (1 - this.cfg.stopBps/1e4);
      // 这里仅给出下单示例；实际需用OCO/触发单封装
      this.router.sendLimitChild({symbol: this.cfg.symbol, side: "buy", px: buyPx, sz: this.cfg.clipSz, tif: "IOC", clientId: `scalp-${now}`});
      // 平仓逻辑交给 PositionManager/TriggerEngine（略）
    }
  }
}
```

## 6. 触发/风控一体化（OCO、止盈止损）
```ts
// execution/TriggerEngine.ts
export interface OCO { takeProfitPx: number; stopPx: number; qty: number; }
// 将策略信号转化为触发单，挂在 Router 前端，确保 STP 与风控校验一致。
```

## 7. 数据与回测
```ts
// backtest/Replay.ts
// 以原始 trades+books 事件重放；策略接口复用生产代码，实现"同一份逻辑"在回测与实盘之间切换。
```

## 8. 监控与可观测性
- **指标**：成交通（maker/taker）、库存、名义敞口、滑点、cancel/replace 比例、延迟 P50/P99、资金费率影响。
- **报警**：延迟>阈值、库存突破、PnL 回撤>阈值、数据断流、挂单失配（shadow book vs venue book）。

---

# 自成交预防（STP）与合规模块
- **订单级**：clientId + 本地影子簿比对，避免与自身挂单交叉；
- **会话级**：多 venue / 多账户时，强制使用不同 `account/owner`；
- **审计日志**：将所有信号、下单、撤单、成交、风控决策写入不可变存储（append-only）；
- **合规守则**：
  1) 禁止任何设计以“制造虚假成交量”为目的；
  2) 保留策略参数与改动记录，支持外部审计；
  3) 采用被动做市 + 合理剥头皮，不进行虚假挂单（spoofing）或层叠（layering）。

---

# 部署与运维
- **语言/环境**：Node 22+，TypeScript 5+；
- **时序**：以 `event-queue` 驱动，严格单线程撮合上下文（防竞态），IO 异步。
- **容错**：断线重连、序列号校验、重放增量事件；
- **配置热更**：YAML/JSON + schema 校验（zod），参数更改写入审计表。

---

# 任务分解（Milestones）
**M1 — 骨架与单 venue 通路（~1–2周）**
- [ ] types 与 ExchangeAdapter 抽象
- [ ] Drift/某 DEX 适配（下单、撤单、WS 行情）
- [ ] 影子订单簿与基础延迟计
- [ ] OrderRouter + SlippageGuard
- [ ] RiskEngine v1（库存/名义限额，kill-switch）

**M2 — 策略最小闭环（~1周）**
- [ ] MarketMaker v1（被动两侧挂）
- [ ] MicroScalper v1（点差触发）
- [ ] TriggerEngine（OCO/止盈止损）
- [ ] Telemetry 仪表盘（Grafana/Prom）

**M3 — 回测 & 复用（~1周）**
- [ ] 事件回放框架，复用策略接口
- [ ] 参数搜索（grid/random）
- [ ] 手续费/资金费率建模与 PnL 分解

**M4 — 多 venue 扩展与合规加固（~1–2周）**
- [ ] 第二家 DEX 适配，跨 venue STP
- [ ] 审计日志与只增存储
- [ ] 断线/重放/重启一致性（快照+增量）

**M5 — 生产化与SRE（~持续）**
- [ ] 蓝绿发布、参数金丝雀
- [ ] 风险参数自动化回滚
- [ ] 异常演练：行情暴涨暴跌、数据缺口

---

# PnL 与费用建模（简化）
```
RealizedPnL = Σ(±qty * (exitPx - entryPx)) - Σ(fees) + Σ(fundingPnL)
fees = makerFee * makerQty + takerFee * takerQty
fundingPnL ≈ positionNotional * fundingRate * holdingTime
```
优化方向：
- 提高 maker 成交占比（返佣）
- 减少 taker 比例与滑点
- 在资金费率极端时段降低库存

---

# 开源/依赖建议
- **math/校验**：`decimal.js`, `zod`
- **网络/WS**：`undici`, `ws`
- **日志**：`pino`, `pino-pretty`
- **观测**：`prom-client`
- **配置**：`dotenv`, `cosmiconfig`

---

# 后续可选增强
- 价格预言机加权（CEX 指南价）防止 DEX 局部失真
- 盘口微结构特征：order-book imbalance、queue position 估计
- 自适应点差：根据 realized volatility/queue alpha 动态调参
- 执行智能体：在风控约束下，对参数进行 bandit 优化

> 以上架构与代码骨架可以直接落到 monorepo 中，按 Milestone 拉分支推进。若你提供目标 DEX/SDK，我可以把 `ExchangeAdapter` 的样例实现补齐。



---

# Delta 中性 + 双向剥头皮（合规模块化方案）
以下是**不涉及对敲**的合规方案：通过**跨 venue / 子账户**持仓对冲实现 Delta≈0，同时在盘口两侧进行**微剥头皮**与**被动成交**，以获取点差与返佣收益。

## 0) 运行前置（假设）
- 标的：BTC-PERP / ETH-PERP
- 交易场所：DEX-A、DEX-B（或一个 venue 的两个独立子账户，启用/自建 STP）
- 费率：maker -2 bps 返佣，taker 5–7 bps
- 风险参数：最大名义 50k–250k，kill-switch 当日 -0.5% 账户净值

## 1) 策略总览
- **目标**：保持净 Delta≈0（跨账户或跨 venue 对冲），在盘口**点差扩张**与**订单流失衡**时进行**方向无关**的短线剥利。
- **收益来源**：
  1) maker 成交点差（spread capture）
  2) taker/maker 组合的微利（短期均值回归或瞬时动量）
  3) 资金费率对冲后残差（可选）
- **关键约束**：
  - STP：避免任何自成交；
  - “先持仓后对冲”，对冲在另一 venue 或子账户完成；
  - 始终有**库存上/下限**与**名义上限**。

## 2) 信号与执行逻辑
### 2.1 盘口与订单流特征
- **Spread 扩张信号**：
  - `spread_bps = (ask1 - bid1) / mid * 1e4`
  - 触发条件：`spread_bps > θ_spread`（如 1.2–2.5 bps，随波动调整）
- **Order Book Imbalance**：
  - `obi = Σ(bids[1:k].sz) / (Σ(bids[1:k].sz) + Σ(asks[1:k].sz))`
  - 极端值（<0.35 或 >0.65）提示瞬时偏移
- **Trade Imbalance（t-rolling）**：
  - 最近 `T=0.5–2s` 内的买入/卖出成交量差
- **Short-term RV（Realized Volatility）**：
  - 以 200–500ms bar 估计；RV 高→扩大目标点差与止损

### 2.2 入场/出场（方向无关）
- **做法 A（被动优先）**：
  1) 在 `mid±δ` 两侧各挂 1–N 层被动单（postOnly）；
  2) 当一侧成交后，**触发对冲**：另一 venue 以市价/紧限价对冲，使 `Δ≈0`；
  3) 同时为已成交腿设置 `OCO`（tp/sl），tp 优先走 maker（排队），sl 用 taker。
- **做法 B（微动量吃单）**：
  1) 当 `spread_bps↑` 且 `trade_imbalance` 指向一侧，薄量吃单进入；
  2) 立即在同一 venue 以 `mid` 附近被动挂出平仓；
  3) 若未成交触发 `IOC` 快速退出。

### 2.3 预期价值（EV）校验
```
EV_per_trade ≈ edge_bps - taker_bps * taker_ratio - slip_bps - cancel_cost_bps
要求：EV_per_trade > safety_bps
```
- `edge_bps` 来自 spread capture 或短期均值回归预期；
- `safety_bps` 通常取 1–2 bps 以上。

## 3) Delta 中性与库存控制
- **控制律（PI/PID 简化）**：
```
Δ_target = 0
error_t = pos_base - Δ_target
hedge_qty = clamp(kp * error_t + ki * Σerror, [-Qmax, +Qmax])
```
- **执行**：在对冲 venue/账户用 `IOC`/紧限价完成；
- **节流**：`min_hedge_interval_ms`，避免抖动；
- **资金费率偏置**（可选）：若当期 funding 对我方不利，附加微偏置减少该方向库存。

## 4) 参数按波动分层（示例）
| regime | spread 触发(bps) | maker 层数 | clipSz | tp/sl(bps) | 冷却(ms) |
|---|---|---|---|---|---|
| 低波动 | 1.2 | 2–3 | 0.5–1x | 2 / 4 | 300–600 |
| 中波动 | 1.8 | 2 | 0.3–0.7x | 3 / 6 | 200–400 |
| 高波动 | 2.5 | 1–2 | 0.2–0.5x | 5 / 10 | 120–250 |
> `x` 为基础手数：`base_clip = max( min( equity * α / mid, maxOrderSz ), tickSz )`

## 5) TypeScript 关键模块（新增/细化）
```ts
// portfolio/PositionManager.ts
export class PositionManager {
  constructor(private exA: ExchangeAdapter, private exB: ExchangeAdapter) {}
  async snapshot(symbol: string) { /* 聚合 A/B 持仓，返回总 Delta */ }
}

// hedge/HedgeEngine.ts
export class HedgeEngine {
  constructor(private ex: ExchangeAdapter, private cfg: { kp:number; ki:number; Qmax:number; minInterval:number }) {}
  private integ = 0; private last = 0;
  compute(pos: number) { this.integ += pos; const raw = this.cfg.kp*pos + this.cfg.ki*this.integ; return Math.max(Math.min(raw, this.cfg.Qmax), -this.cfg.Qmax); }
  async maybeHedge(symbol: string, pos: number) {
    const now = Date.now(); if (now - this.last < this.cfg.minInterval) return;
    const q = this.compute(pos); if (Math.abs(q) < 1e-8) return;
    // 市价/紧限价对冲
    await this.ex.place({ symbol, side: q>0?"sell":"buy", px: await this.bestPx(symbol, q), sz: Math.abs(q), tif: "IOC", clientId:`hedge-${now}`});
    this.last = now;
  }
  private async bestPx(symbol: string, qty:number){ /* 引用本地簿与滑点守卫 */ return 0; }
}

// policy/ExecutionPolicy.ts
export interface ExecutionPolicy { choose(obi:number, spreadBps:number, rv:number): {mode:"passive"|"taker"; layers:number; tp:number; sl:number}; }
```

## 6) 运行时状态机
```
IDLE → (信号触发) → ENTER
ENTER → (下单成功) → MANAGE
MANAGE → (对冲完成 & OCO 挂好) → HOLD
HOLD → (tp/sl 任一触发) → FLAT
任一状态 → (kill-switch/断流) → HALT
```

## 7) 回测与仿真
- 重放 `book+trades`（10–50ms 级粒度）；
- 费用/滑点模型：maker/taker 分别估算；
- 资金费率：按周期离散计入；
- 报表：Sharpe（秒级）、胜率、buckets（按 spread/obi/rv 分层），库存时间、对冲成本。

## 8) 观测与风控指标（上线必备）
- 指标：`maker_ratio`, `avg_edge_bps`, `real_slip_bps`, `hedge_cost_bps`, `delta_abs`, `latency_p99`, `cancel_rate`；
- 告警：`delta_abs>阈值`、`PnL_drawdown>阈值`、`数据断流`、`STP 命中`、`对冲失败`；
- 审计：信号 → 决策 → 下单 → 成交 全链路追踪（trace id）。

## 9) 上线清单（Tasks）
1. **接口层**：完成 2 个目标 DEX 的 `ExchangeAdapter`（下单/撤单/WS）
2. **影子订单簿**：合并增量深度，提供 mid/top/obi/spread/rv
3. **OrderRouter**：限价/IOC + 滑点守卫 + STP 检查
4. **Signals**：spread/obi/trade_imbalance/rv 实现与校准
5. **Strategy**：被动层 + taker 模式切换的 `ExecutionPolicy`
6. **PositionManager & HedgeEngine**：跨 venue Delta 汇总与对冲
7. **TriggerEngine**：OCO（tp/sl）与超时退出
8. **Risk/Compliance**：名义/库存/回撤限额、kill-switch、审计日志
9. **Backtest**：事件重放、费用/滑点/资金费率模型
10. **SRE**：Prom+Grafana 仪表盘、报警、重连/重放、参数热更

## 10) 配置样例（YAML）
```yaml
symbol: BTC-PERP
venues:
  - name: dexA
    key: ${A_KEY}
  - name: dexB
    key: ${B_KEY}
mm:
  layers: 2
  spread_bps: 1.6
  clip_usd: 1200
scalper:
  trigger:
    spread_bps: 1.8
    min_cooldown_ms: 250
  tp_bps: 3
  sl_bps: 6
risk:
  max_notional: 100000
  max_base_abs: 0.8
  kill_dd: -0.5%
hedge:
  kp: 0.6
  ki: 0.05
  qmax: 0.4
  min_interval_ms: 200
```

## 11) 上线演练（Playbook）
- **冷启动**：先在 `notional=小` 下 30–60 分钟金丝雀；
- **波动骤升**：切换高波动参数或自动降层/降 clip；
- **数据断流**：立即撤单→HALT；
- **对冲失败**：限制新增信号，仅处理存量仓位→安全退出；
- **资金费率极端**：降低持仓时长/名义，或只开对资金费率有利的一侧被动单。

---

