交易所入职七日冲刺

四个产品

网格长什么样

 price
 high 30000 ─────────────────── SELL   ← 区间上沿
      29500 ─────────────────── SELL
      29000 ─────────────────── SELL
 now  28750 ········●··········
      28500 ─────────────────── BUY
      28000 ─────────────────── BUY
 low  27500 ─────────────────── BUY    ← 区间下沿

 BUY  filled @28500 ──► place SELL @29000   (one level up)
 SELL filled @29000 ──► place BUY  @28500   (one level down)
 profit per round trip = spacing × qty − fee(buy) − fee(sell)

最靠近当前价的那一格空着。每成交一笔，就在相邻格挂一张反向单，所以网格永远是"下面挂买、上面挂卖"。

动画：让网格自己跑

马丁补仓：钱是怎么放大的

跟单链路

 Leader opens LONG 1 BTC   (leader equity 10,000 U)
        │   event: leader.fill
        ▼
 ┌───────────────┐
 │  CopyEngine   │── load followers(leaderId)
 └───────┬───────┘
         ├──► F1  ratio 0.5x   equity 5,000  → 0.25  BTC
         ├──► F2  fixed 200 U                 → 0.003 BTC  (rounded DOWN to lot)
         ├──► F3  fixed 50 U                  → SKIP  below minQty
         └──► F4  balance too low             → SKIP  insufficient + notify

编程验证

今日实操（只看不下单，约 30 分钟）

1. 找到产品：打开任一大交易所的"交易机器人 / 策略交易 / 策略广场"页面（各家叫法不同），不用注册也大多能看。
2. 抄现货网格的参数栏：点"创建现货网格"，把每个输入框的名字抄下来：价格区间上下限、网格数量、等差 / 等比、投资额、每格利润率、止盈价、止损价、触发价。每一项旁边写一句"它是什么"，对不上就回笔记查。
3. 再抄三个：合约网格（多了方向、杠杆、预估强平价）、定投 / 马丁（首单、补仓倍数、价格间隔、最大补仓次数、止盈比例）、跟单（带单员的收益率、最大回撤、跟单人数、分润比例）。
4. 算一次：用上面的马丁表，首单 100 U、倍数 2、补 5 次，算出一共要准备多少钱；再看创建页里"投资额"那一栏的最低要求是不是和你算的差不多。

完成标志：一张"四个产品 × 参数"的对照表。D12 会在模拟盘里真的把它们建出来。

自测

打卡

订单

 submit ──► OPEN ──fill──► PARTIALLY_FILLED ──fill──► FILLED
              │                    │
            cancel               cancel
              ▼                    ▼
          CANCELED        CANCELED  (filledQty > 0 !)
 reject ──► REJECTED   (never reached the book)

 place() timed out ──► state = UNKNOWN  → query by clientOid, never assume

"部分成交后撤单"是最容易被漏掉的状态：订单是 CANCELED，但仓位已经变了。

精度：最能看出懂不懂行的地方

 raw price    27123.456        tickSize 0.1
 BUY   → round DOWN → 27123.4    don't overpay
 SELL  → round UP   → 27123.5    don't undersell the grid target
 qty   → round DOWN to lotSize  never exceed available balance
 check → price × qty ≥ minNotional, else the exchange rejects it

上面是网格场景下常见的约定，具体方向以你们团队的规范为准。重点是：任何金额和价格都不能用 double 算。

BigDecimal tick = new BigDecimal("0.1");
BigDecimal buy  = raw.divide(tick, 0, RoundingMode.DOWN).multiply(tick);
BigDecimal sell = raw.divide(tick, 0, RoundingMode.UP).multiply(tick);
// 注意：new BigDecimal(0.1) 是错的，要用字符串构造

编程验证：先用 double 写，看它怎么挂

永续合约

 index price  = weighted spot prices from several exchanges
 mark price   = index + smoothed premium
                → PnL and liquidation use MARK, not last trade

 funding (commonly every 8h):
   rate > 0  → longs  pay shorts   (perp above spot, cool the longs)
   rate < 0  → shorts pay longs

 margin mode:
   isolated → only this position's margin is at risk
   cross    → the whole account backs the position

 liquidation → insurance fund → ADL (auto-deleverage) if fund is not enough

强平价计算器（逐仓 · U 本位 · 忽略手续费和阶梯保证金）

今日实操（公开接口，不用账号，约 30 分钟）

1. 查精度：浏览器打开 https://api.binance.com/api/v3/exchangeInfo?symbol=BTCUSDT，在返回里找 PRICE_FILTER 的 tickSize、LOT_SIZE 的 stepSize、最小下单金额那一项。把这三个数代进上面 roundToStep 编程题的测试里跑一次。
2. 查三个价格：打开 https://fapi.binance.com/fapi/v1/premiumIndex?symbol=BTCUSDT，抄下 markPrice（标记价格）、indexPrice（指数价格）、lastFundingRate（资金费率）、nextFundingTime（下次结算时间，毫秒时间戳，换成北京时间）。
3. 对界面：打开交易所网页的 BTCUSDT 永续页面，顶部找到同样几个数，确认和接口返回一致，并看看最新价和标记价差多少。
4. 算强平价：把当前标记价填进上面的强平价计算器，10 倍做多，抄下"距开仓价"。再改成 20 倍，看强平价离你近了多少。

接口地址以官方文档为准；网络访问遵守所在地和公司的规定，打不开就换其他交易所的公开接口，字段名不同但意思一样。

自测

打卡

同步流程

 1. open WebSocket, BUFFER deltas          seq: 101 102 103 104 ...
 2. GET REST snapshot                     snapshot.seq = 102
 3. drop buffered deltas with seq ≤ 102
 4. apply 103, 104, ... strictly in order
 5. gap?  (got 106 right after 104)  ──►  discard local book, go back to 1

 size = 0 in a delta  →  remove that price level

不同交易所的字段名不同（有的叫 sequence，有的叫 u / U），逻辑都是这一套。去看一家交易所公开 API 文档里"如何正确维护本地订单簿"那一节。

动画：丢一条包试试

编程验证

今日实操（终端里看真实行情，约 40 分钟）

1. 拉快照：curl 'https://api.binance.com/api/v3/depth?symbol=BTCUSDT&limit=5'，看 lastUpdateId（快照的序列号）和前 5 档买卖盘。
2. 订阅增量：装一个命令行 WebSocket 客户端（macOS 上 brew install websocat），执行 websocat wss://stream.binance.com:9443/ws/btcusdt@depth@100ms。每条消息里的 U 是这批增量的第一个序列号，u 是最后一个。
3. 检查连续：抄连续三条消息的 U 和 u，确认"这一条的 U = 上一条的 u + 1"。这就是 D3 的跳号检查。
4. 对齐快照：一边开着订阅，一边再拉一次快照，找出第一条满足"U ≤ lastUpdateId + 1 ≤ u"的增量：从它开始应用，前面的丢掉。这就是"先缓冲、再拉快照"。
5. 看 K 线：curl 'https://api.binance.com/api/v3/klines?symbol=BTCUSDT&interval=1h&limit=3'，每一行前几个数依次是开盘时间、开、高、低、收、成交量，对照笔记里 K 线那一节。

地址和对齐规则以官方文档为准，各家不同；网络访问遵守所在地和公司的规定。

自测

打卡

整体结构

 ┌──────────┐  ticks   ┌──────────┐ intents ┌──────────────┐
 │ MarketWS │ ───────► │ Strategy │ ──────► │ OrderGateway │ ──► PaperMatcher (D4)
 └──────────┘          └────▲─────┘         └──────┬───────┘     Exchange API (real job)
                            │ state                │ clientOid
                       ┌────┴──────┐  order/fill   │
                       │ GridState │ ◄─────────────┘
                       └────┬──────┘
                            ▼
                       EventLog (append-only) ──► replay on restart (D5)

项目骨架

grid-bot/
├── market/  PublicWsClient.java     // 订阅公开成交流，不需要账户
├── sim/     PaperMatcher.java       // 价格穿过挂单价 → 生成成交事件
├── core/    GridLevels.java         // D1 的 gridLevels
│            GridState.java          // 每一格：BUY / SELL / EMPTY
│            GridStrategy.java       // 收到成交 → 算下一张单（下面这道题）
├── order/   OrderIntent.java  ClientOid.java
├── log/     EventLog.java           // D5
└── copy/    LeaderPublisher.java  FollowerConsumer.java   // D6

编程验证：策略的核心一步

自测

打卡

下单超时怎么办

 place(clientOid = G7-3-B-12) ──► timeout ??
      │
      ├─ ✗ retry with a NEW clientOid   → may create a duplicate order
      └─ ✓ query by the SAME clientOid
             ├─ found     → adopt its real state
             └─ not found → re-place with the SAME clientOid
                            (exchange rejects duplicates → idempotent)

// gridId-level-side-cycle：重启后能从本地状态重新算出来
String clientOid = gridId + "-" + level + "-" + side.charAt(0) + "-" + cycle;

重启对账

 local (EventLog replay)          exchange (source of truth)
 ───────────────────────          ─────────────────────────
 A  OPEN                ◄──────►  A  OPEN              → keep
 B  OPEN                ◄──────►  B  FILLED            → markFilled + next grid step
 C  OPEN                ◄──────►  (not found)          → replace (same clientOid)
                                  X  OPEN, unknown     → cancelOrphan

 rule: write the event to the log FIRST, then mutate memory

这就是对账。你做过电商对账，这里的思路一样：以外部为准，本地差异逐条归类处理。

编程验证

自测

打卡

两段式设计

 leader.fills           ┌───────────────┐        copy.orders           ┌──────────────┐
 key = leaderId  ─────► │ FanoutService │ ─────► key = followerId ─────► │ OrderWorkers │
                        └───────────────┘                               └──────────────┘
 ordered per leader       explode 1 → N          spread evenly,
 (hot leader = hot        (light work only)      ordered per follower
  partition)

 clientOid = leaderFillId + "-" + followerId   → any retry creates the SAME id

producer.send(new ProducerRecord<>("leader.fills", leaderId, fill));    // 第一段
producer.send(new ProducerRecord<>("copy.orders", followerId, order)); // 第二段

本地起 Kafka：docker run -d --name kafka -p 9092:9092 apache/kafka:3.8.0

动画：换一个分区键

编程验证

自测

打卡

六张故障卡：在你自己的项目里逐个制造一遍

编程验证：幂等消费

一页总结（自动保存在本机浏览器）

打卡

后台全景

 client ─► gateway ─► order svc ─► pre-trade risk ─► sequencer ─► matching engine
                         │ freeze funds                                  │ trades
                         ▼                                               ▼
                      account ◄──────────── clearing ◄────────────── trade events
                                                                         │
                                                              market data / push ─► users
 perp only:
   index ─► mark price ─► risk engine ─► liquidation engine ─► insurance fund ─► ADL
   timer (commonly 8h) ─► funding settlement ─► account

gateway 网关 · order svc 下单服务 · pre-trade risk 下单前风控检查 · freeze funds 冻结资金 · sequencer 定序 · matching engine 撮合引擎 · clearing 清算 · account 账户 · trades 成交 · market data / push 行情和推送 · index 指数价 · mark price 标记价 · risk engine 风险引擎 · liquidation engine 强平引擎 · insurance fund 保险基金 · ADL 自动减仓 · funding settlement 资金费结算。现货只走上半张图；合约多出下面两条：一条盯着标记价随时准备强平，一条定时收付资金费。

录屏：一笔现货限价单的一生

编程验证：价格优先、时间优先

强平引擎沙盘（逐仓 · U 本位 · 做多 1 BTC @ 60,000 · 10 倍）

今日实操（在交易所网站上找真实参数，约 30 分钟）

1. 阶梯保证金：找到 BTCUSDT 永续的"杠杆与保证金档位"表（各家叫法不同，常在合约规则或下单面板的杠杆设置里），抄前三档：名义价值区间、最高杠杆、维持保证金率。代进 D8 笔记的阶梯保证金计算器，算 1 BTC、10 倍的强平价，和上面沙盘的 54,271 比一比。
2. 保险基金：找到交易所公开的保险基金余额页面，记下 BTCUSDT 这一栏的余额和最近的变化。
3. 自动减仓指示：在合约页面的仓位栏找自动减仓排队指示（常见是一排小灯），读一下帮助说明，它排的是什么。
4. 手续费等级：找到费率页，抄普通用户的现货和合约挂单 / 吃单费率，按它算一次"600 U 合约仓位开仓挂单、平仓吃单"一共多少手续费。

自测

打卡

量化系统的五个环节

 data ──► backtest ──► strategy ──► paper trading ──► live
   ▲                                                            │
   └──────── live fills and PnL go back to data, re-check ◄─────┘

data 数据 · backtest 回测 · strategy 策略 · paper trading 模拟盘（真行情、假钱）· live 实盘 · live fills and PnL go back to data, re-check 实盘的成交和盈亏回流成新数据，拿来和回测对账。回测排在策略前面，是因为先得有一套能信的回测框架，才能拿它筛策略；否则每个想法都没法判断好坏。

策略地图

 signal ─► position sizing ─► execution ─► risk check
   ▲                                              │
   └────────────── fills / PnL feedback ◄─────────┘

 backtest:  history bars ─► same strategy code ─► simulated matcher (fee, slippage)
                                                  ─► equity curve ─► metrics

signal 信号 · position sizing 定仓位 · execution 执行下单 · risk check 风控 · fills / PnL feedback 成交和盈亏回流 · backtest 回测 · history bars 历史 K 线 · same strategy code 同一份策略代码 · simulated matcher 模拟撮合 · equity curve 资金曲线 · metrics 指标。回测和实盘最好跑同一份策略代码，只换掉"行情从哪来"和"订单发到哪"。

双均线和海龟：规则一页纸

 MA crossover   MA(n) = average of the last n closes
   fast crosses ABOVE slow  (golden cross) ─► BUY
   fast crosses BELOW slow  (death cross)  ─► SELL / go short
   signal on close of day t ─► trade on day t+1   (no peeking!)

 Turtle, system 1   (system 2: 55-day entry, 20-day exit)
   entry : close breaks the 20-day high  ─► BUY 1 unit
   N     : 20-day smoothed true range,  N = (19 × N_prev + TR) / 20
   unit  : equity × 1% / N              ─► a 1N move = 1% of equity
   add   : +1 unit every 0.5N in favor, max 4 units
   stop  : 2N below the LAST add, all units move up together
   exit  : close breaks the 10-day low   ─► SELL all

MA crossover 双均线 · MA(n) n 日均线 · average of the last n closes 最近 n 天收盘价的平均 · fast / slow 快线 / 慢线 · golden cross 金叉 · death cross 死叉 · go short 做空 · no peeking 不许偷看 · Turtle system 1 海龟系统一 · breaks the 20-day high 突破过去 20 天最高价 · true range 真实波幅 · unit 头寸单位 · add 加仓 · in favor 朝赚钱的方向 · stop 止损 · exit 离场。双均线只回答"什么时候进出"；海龟把入场、仓位、加仓、止损、离场全写死了，这才叫"一套能照着执行的规则"。

编程验证：双均线只在"交叉那一天"发信号

编程验证：海龟的加仓和止损计划

策略回测器：网格 · 双均线 · 海龟

资金费率套利计算器

编程验证：收益、最大回撤、夏普

今日实操（用真实数据回测，约 40 分钟）

1. 下载数据（数据环节）：打开 https://data.binance.vision/，进 data → spot → monthly → klines → BTCUSDT → 1d，下载最近 12 个月的 zip，解压出 CSV。没有表头，第 1 列是开盘时间，第 5 列是收盘价。或者直接存接口返回：curl 'https://api.binance.com/api/v3/klines?symbol=BTCUSDT&interval=1d&limit=365' -o btc.json。
2. 先检查数据：打开一个 CSV 看看有没有缺天、有没有重复（D9 笔记"数据"那节的缺口检查）。
3. 导入回测（回测环节）：在上面的策略回测器点"导入 CSV / JSON"，一次选中全部文件，页面会按时间排序、去重，只在你本机解析，不上传。
4. 三种策略各跑一遍（策略环节）：网格区间自动取开头价格的 ±10%；双均线试 10/30 和 20/60；海龟试系统一和系统二。每个记下收益、最大回撤、夏普，和"拿着不动"比。
5. 写一句结论：这一年是趋势多还是震荡多？哪个策略占便宜？如果换一年呢？（过拟合）

自测

打卡

先记住四条红线

录屏：开一单合约，从头到平仓

手动练习顺序

签名计算器

编程验证：下单前自己先挡一遍

实操记录表（自动保存在本机浏览器）

先在"自己先算"一栏填你算的数，再去测试网操作，把界面上看到的数填进"界面实际"。两边差不到 0.5% 算对上；对不上就去查是费率、精度还是维持保证金档位不一样，这比对上了学到的更多。

自测

打卡

指标实验台

合约数据四种组合

这些是参考，不是买卖信号。持仓量、多空比、爆仓数据各家都有公开页面，叫法和统计口径不同（多空比有"人数比"和"大户持仓比"两种，差别很大）。

编程验证：EMA

编程验证：RSI

今日实操（TradingView 或任一交易所的 K 线图，约 60 分钟）

1. 打开图：TradingView 搜 BTCUSDT，选一家交易所的永续合约（代码里通常带 .P），周期切到 4 小时。交易所网页的 K 线图也可以，大多就是嵌的 TradingView 图表。
2. 多周期：依次切日线、4 小时、15 分钟，各用一句话写"现在是涨、跌还是横盘"。三个周期说法不一致很正常，记下来。
3. 加指标：指标里搜 EMA 加两次，长度改成 20 和 60；再加 RSI（14）和布林带（20, 2）。把最后一根的 EMA20、RSI 抄下来。
4. 画线：用水平线工具在最近两个明显低点画一条支撑线，用趋势线工具连两个抬高的低点。在支撑线下方设一个价格提醒。
5. 看合约数据：在交易所的"合约数据"页（各家叫法不同）找到这个币的持仓量、多空比、资金费率，按上面的四种组合写一句解读。
6. 写 Pine 回测（需要免费账号）：打开 Pine 编辑器，粘贴下面的双均线策略，加到图上，打开策略测试器看净利润、最大回撤、胜率、交易次数；把手续费改成 0 再看一次。
7. 用不了 TradingView：去 D9 回测器点"导入 CSV"，用真实日 K 做第 6 步同样的事。

//@version=5
strategy("EMA cross 20/60", overlay=true, initial_capital=10000,
     default_qty_type=strategy.percent_of_equity, default_qty_value=100,
     commission_type=strategy.commission.percent, commission_value=0.1)
fast = ta.ema(close, input.int(20, "fast"))
slow = ta.ema(close, input.int(60, "slow"))
plot(fast, "fast", linewidth=2)
plot(slow, "slow")
if ta.crossover(fast, slow)
    strategy.entry("L", strategy.long)      // 金叉：开多
if ta.crossunder(fast, slow)
    strategy.close("L")                     // 死叉：平多

Pine 是 TradingView 的脚本语言。策略默认在信号那根 K 线收盘后、下一根开盘时成交，和 D9 讲的"第 t 天出信号、第 t+1 天成交"是一回事。菜单名、版本号以当时界面为准。

自测

打卡

交易员的一笔单

 plan ─► size by stop ─► conditional order + TP/SL ─► manage (trail, scale out, breakeven)
   ▲                                                                      │
   └──────────────── journal + weekly review ◄──────────── exit ◄──────────┘

plan 交易计划 · size by stop 以损定仓：先定止损再算数量 · conditional order 计划委托 · TP/SL 止盈止损 · manage 持仓管理 · trail 追踪止损 · scale out 分批止盈 · breakeven 止损移到保本 · exit 离场 · journal 交易日志 · weekly review 每周复盘。新手的顺序常常是"先下单、再想止损、亏了才复盘"，正好反过来。

以损定仓计算器

录屏：追踪止损怎么一路跟上去

编程验证：以损定仓

编程验证：追踪止损

交易日志（自动保存在本机浏览器）

每笔填：计划风险（U，就是以损定仓时"最多亏多少"）、实际盈亏（U）、是否按计划执行、一句话原因。R 倍数 = 实际盈亏 ÷ 计划风险：+2R 就是赚了两倍计划风险。一周以后看平均 R（就是每笔的期望值）和"没按计划"的次数，这比胜率有用得多。

今日实操（模拟盘，约 90 分钟）

1. 写计划：挑一个 D11 画过线的位置，按 D12 笔记的模板写：方向和理由、入场、止损、止盈 1 和 2、失效条件。用上面的计算器算数量，盈亏比低于 2 就换一个位置。
2. 下计划委托：在模拟盘用"计划委托 / 条件单"（各家叫法不同）挂入场单，填触发价和委托价，同时带上止盈止损。先确认触发价用的是最新价还是标记价。
3. 管仓：到第一个止盈先平一半，把剩下一半的止损移到入场价（保本）；再给剩下的挂一个回调 3% 的追踪止损。
4. 记日志：离场后把这一笔填进上面的日志，截一张图存起来。
5. 建现货网格：在模拟交易里手动填参数，不用"AI 推荐"：区间用 D11 画的支撑和阻力，格数要满足"每格利润率 > 2 × 手续费率"（按 D1 的网格公式先算），填止损价。
6. 建合约网格：选中性或做多，杠杆不超过 3 倍，把界面给出的预估强平价和你用 D2 公式算的对一下。
7. 建定投 / 马丁：先用 D1 的马丁表算"最多补几次、一共要准备多少钱"，再填首单、补仓倍数、价格间隔、最大补仓次数、止盈比例。
8. 跟一次单：挑带单员时看最大回撤、带单天数、平均杠杆、跟单人数，别只看收益率；用小额按固定金额跟。
9. 24 小时后：每个产品记 5 个数：成交次数、已实现利润、浮动盈亏、手续费合计、离强平价（或止损价）还有多远。

模拟交易入口和参数名各家不同，以界面为准。入职后用公司的币，也按"先手动、再小额策略"的顺序来，并遵守公司规定（D10 红线）。

自测

打卡