衍生产品交易所

在衍生产品交易所市场中，大家所交易的是经过交易所标准化之后的衍生产品。

衍生产品交易所历史：为了将农场主和商人联系起来，芝加哥期货交易所（CBOT）于 1848 年成立。CBOT主要职能是将交易的谷物进行数量和质量标准化。

几年后，CBOT首先开发了期货类合约，

技术交易

量化交易

量化交易，在学术上指利用现代统计学、数学算法、计算机技术，进行交易的证券投资方式。从庞大的历史数据中筛选可能带来超额收益的，用多种大概率事件的方式来制定策略。用数量模型来检验、固化这些策略，再严格地执行这些策略，从而指导投资。目的是获得可持续的、稳定的、高于平均收益的超额回报。
量化交易的概念很广，本质上和程序化并无关系，因为它只是在历史中进行分析，分析的结果在程序化交易之前就会完成，换句话说，完全可以依赖纸和笔计算。因此量化交易只是一种思想，不必须是自动化交易。

高频交易

高频交易是量化投资领域的一个流派。字面上的高频，指每次交易从开仓到平仓只有很短的时间，一般从几分钟到几微秒。有的时候为了试探（反复挂单、撤单），还会更快，到纳秒级别。
高频交易主要依赖市场的价格波动获利。高频交易以外的，多依赖“趋势”获利。依赖市场的波动，就决定了其需要程序化。

市场行情数据

L1（Level 1）数据：“Tick Data” / “Best Bid & Offer (BBO)”
一句话解释：只告诉现在市场上最好的价格是多少。

包含内容：
- 买一价（Best Bid）& 数量：当前出价最高的买单。
- 卖一价（Best Ask）& 数量：当前出价最低的卖单。
- 最新成交价（Last Traded Price）和成交量。
缺点：
- 不知道深度。如果想买 100 个 BTC，L1 显示“卖一”只有 1 个 BTC，你不知道吃掉这 1 个之后，剩下的 99 个要花多少钱买（这就是滑点）。

卖一价（Ask 1），指的是最便宜的价格。如果现在发市价单买入，最先成交的就是它。
卖二价（Ask 2），指的是第 2 便宜的价格。
卖五价（Ask 5），指的是第 5 便宜的价格。

L2（Level 2）数据：“Order Book Depth”（深度行情）/ “MBP” (Market By Price)
一句话解释：告诉每个价格档位上堆积了多少挂单。这是量化交易最主流的数据形式。

学术名称：MBP (Market By Price)——按价格聚合
包含内容：
- 买方前 N 档（比如，Bid 1 ~ Bid 20）的价格和总量
- 卖方前 N 档（比如，Ask 1 ~ Ask 20）的价格和总量
- 注意：它把所有在 $90,000 价格买入的人合并成一个总数（例如5.5 BTC），你不知道这 5.5 BTC 是由一个大户挂的，还是由 100 个散户挂的。
开发视角（重点）：
- 数据结构：通常需要 2 个有序容器（因为价格必须排序）
  - std::map<double, double, std::greater>（买盘，价格从高到低）
  - std::map<double, double, std::less>（卖盘，价格从低到高）
- 推送机制
  - Snapshot（全量快照）：一次性给你当前的完整列表。
  - Update / Delta（增量更新）：之后只发变化。例如：“价格 $90,001 的数量变成了 3.0”。你的 C++ 程序必须在本地根据 Delta 实时维护这个 Map。
- 难点：必须保证顺序处理，如果丢失了一个 Delta 包，本地订单簿就废了（Crossed Book），必须重新请求 Snapshot。

L3（Level 3）数据：“Market By Order”（逐笔委托）/ “MBO”
一句话解释：给你看最原始的流水，每一笔具体的下单、撤单、修改都有记录。

学术名称：MBO (Market By Order)——按订单明细。
包含内容：
- 订单号 ID，动作（挂单、撤单、成交），价格，数量
特点：能看到排队情况。在 L2 中，只知道 $90,000 有 5.5 BTC 在卖，但在 L3 中，你知道你的订单排在队伍中的第几位（Queue Position）。
开发视角（高难度）：
- 数据量：极其巨大。行情波动大时，每秒可能数万条消息。
- 数据结构：
  - 需要维护一个巨大的 Hash Map (std::unordered_map<OrderID, OrderInfo>)来索引每一个活着的订单。
  - 同时还需要维护类似 L2 的有序结构来计算价格。
- 用途：高频做市（Market Making）、微观结构分析、冰山单探测。

直观数据对比总结

假设现在的市场情况是：

张三想以 $100 买 1 个币。
李四想以 $100 买 2 个币。
王五想以 $101 卖 5 个币。

数据级别	你看到的数据 (JSON 示意)	你的 C++ 程序感知
L1	`{"bid": 100, "ask": 101}`	这是一个简单的变量更新。
L2 (MBP)	`{"bids": [[100, 3]], "asks": [[101, 5]]}`	知道 $100 处总共有 3 个币在买，但不知道是谁。
L3 (MBO)	`[{"id": "A", "px": 100, "sz": 1}, {"id": "B", "px": 100, "sz": 2}, ...]`	知道有两个单独的订单，ID A 和 ID B。如果 ID A 撤单了，你就知道剩下列队的 ID B。

概念理解

现在市场上有一群人在喊价：

买家群（想买的人）：
- 小张：“我出 9900 元买。”
- 小李：“我出 9950 元买。” <-- 出价最高，他是“买一”
- 小王：“我出 9800 元买。”
卖家群（想卖的人）：
- 老赵：“我 10100 元才卖。”
- 老钱：“我 10050 元才卖。” <-- 要价最低，他是“卖一”
- 老孙：“我 10200 元才卖。”

A. 买一价 (Best Bid)

定义： 此时此刻，所有想买的人里，出价最高的那个价格。
例子里的值： 9950 元（小李的价格）。
含义： 如果你现在手里有一台 iPhone 想立马卖掉（市价卖单），你只能卖给小李，拿到 9950 元。
C++ 视角： OrderBook 买单队列（Bid Queue）的队头（Top）。通常是 std::map 的 rbegin() 或者 std::vector 的 [0]。

B. 卖一价 (Best Ask / Best Offer)

定义： 此时此刻，所有想卖的人里，要价最低的那个价格。
例子里的值： 10050 元（老钱的价格）。
含义： 如果你想立马买一台 iPhone（市价买单），你必须接受老钱的价格，支付 10050 元。
C++ 视角： OrderBook 卖单队列（Ask Queue）的队头（Top）。

C. 买卖价差 (Spread)

定义： 卖一价 - 买一价。
计算： 10050 - 9950 = 100 元。
重要性： 只要没有人愿意妥协（买家不加价，卖家不降价），交易就不会发生，市场就僵持在这里。Spread 越小，说明流动性越好。

D. 最新成交价 (Last Traded Price / Last Price)

定义： 上一笔已经发生的交易，是多少钱成交的。
时态： 这是“历史”！ 它是过去式。
例子： 也许 1 分钟前，有个急着买手机的人，用 10000 元买走了一台。
当前状态： 虽然“最新成交价”是 10000，但现在市场上卖最便宜的都要 10050。
坑点： 很多小白看着最新成交价是 10000，以为自己挂单 10000 肯定能买到，其实买不到，因为现在的卖家底线是 10050。

E. 成交量 (Volume)

定义： 在一段时间内（比如过去24小时，或者这一根K线的时间内），总共成交了多少个（单位是币的个数，不是金额）。
例子： 刚才那一笔交易成交了 1 台手机，成交量就是 1。如果刚才那个人买了 5 台，成交量就是 5。

滑点

冲击成本滑点（Impact Cost）

这是因为你的单子太大，而市场当前的流动性（挂单量）不足。

这是 L1 的缺点，如果想买 100 个 BTC，L1 显示“卖一”只有 1 个 BTC，你不知道吃掉这 1 个之后，剩下的 99 个要花多少钱买。

档位 (Level)	价格 (Price)	挂单量 (Quantity)	你的视角
卖一 (Ask 1)	10,000	1 个	<-- L1 数据只显示这个，你以为 10,000 能买到
卖二 (Ask 2)	10,001	9 个	<-- L1 看不到，但在 OrderBook 内存里
卖三 (Ask 3)	10,005	90 个	<-- 更贵的价格
你的操作：
你下了一个市价单 (Market Order)，买入 100个 BTC。
撮合引擎的执行逻辑 (Matching Engine Logic)：

先吃掉卖一：买 1 个 @ 10,000。花费 10,000。
还缺 99 个，继续吃卖二：买 9 个 @ 10,001。花费 90,009。
还缺 90 个，继续吃卖三：买 90 个 @ 10,005。花费 900,450。

最终结果计算：

总花费： $1,000,459$
实际平均成交价： $1,000,459 / 100 = \mathbf{10,004.59}$
预期价格 (卖一价)： 10,000

滑点计算：

10,004.59 (实际) - 10,000 (预期) = \mathbf{4.59}

你每买一个币，比预期多花了 4.59 元。这就是因为“没有深度”导致的滑点。

延迟滑点（Latency Slippage）——拼手速

这是因为价格变动太快，而你的网络/程序太慢。这种滑点在做高频交易（HFT）或抢开盘时最常见。
场景模拟：

T0 时刻： 你的 C++ 程序收到行情，卖一价是 10,000。
T1 时刻： 你的策略觉得便宜，发送买单。
网络传输 (50ms)…
T2 时刻： 你的买单到达交易所。
- 但是！ 在这 50ms 里，有一个比你更快的量化团队（或者某个大户）已经把 10,000 的单子吃光了。
- 现在的卖一价已经变成了 10,002。
结果： 你的市价单以 10,002 成交。
滑点： $2。

带滑点保护的限价单

在实盘交易 (Execution) 中为了防止出现巨大的滑点（比如突然有人撤单，导致卖二价格直接跳到 11,000），我们通常不直接使用市价单 (Market Order)，而是使用 带滑点保护的限价单 (Market-with-Protection / Limit Order with Slippage Tolerance)。

// 假设当前卖一价是 10000
double best_ask = 10000.0;
double slippage_tolerance = 0.001; // 允许 0.1% 的滑点

// 我们发一个限价单，价格定在 10010
// 意思是：我愿意买，但我最高只接受 10010，超过这个价我就不买了。
double limit_price = best_ask * (1 + slippage_tolerance); 

send_limit_order(SIDE_BUY, limit_price, quantity);

Crypto 期现套利（资金费率套利，Funding Rate Arbitrage）

假设要对 ETH 套利。

现有资金：1000 USDT
目标：实现 Delta Neutral（中性），不管 ETH 涨跌，1000 U 本金基本不变，但一直能赚利息。

资金分配

留 500 U 准备买现货。
- 标的：ETH-USDT
- 操作：限价单，当前卖一价
留 500 U 充当合约的保证金 (Margin)。永续合约交易——U 本位合约
- 标的：ETH-USDT-SWAP（永续）
- 模式设置：
  - 全仓 / 逐仓：选逐仓（Isolated）比较安全，方便计算。
    - 逐仓（Isolated Margin）：你有 1000 块。你拿 100 块去开个空单，如果亏损超过 100 块，系统只没收这 100 块，强行平仓。你账户里剩下的 900 块非常安全，纹丝不动。
    - 全仓（Cross Margin）：只要你账户里总共还有钱，就不会爆仓。亏损可以一直吞噬你的余额，直到 1000 块全部亏光，才会爆仓。
  - 杠杆倍数（Leverage）：选 1x（一倍）。意味着空单价值 = 保证金，永远不会爆仓（除非交易所倒闭或者极端插针）
- 操作：卖出 / 做空（Short）。和现货数量严格一致。当前买一价。

持有与收租（Maintenance）

现在的持仓状态：
持有相同数目的 ETH 现货（多头）和空单（空头）。

此时的盈亏逻辑（PnL Analysis）：

如果 ETH 暴涨 100%： 现货赚 500 U，合约亏 500 U。总资产 = 1000 U (不亏不赚)。
如果 ETH 暴跌 50%： 现货亏 250 U，合约赚 250 U。总资产 = 1000 U (不亏不赚)。
这就是 Delta Neutral (中性)。

钱从哪来？—— 资金费率 (Funding Fee)

每隔 8 小时（通常是 00:00, 08:00, 16:00），交易所以及多空双方会进行结算。
如果 费率是正的 (e.g., +0.01%)，说明做多的人多。多头要付钱给空头。

我们是空头，所以会收到：$$收益 = 持仓名义价值 \times 费率$$$$收益 = 500 \text{ U} \times 0.01% = 0.05 \text{ U}$$这一天会收 3 次租。如果行情好（大牛市），年化收益率能达到 15% - 50%。

平仓与提现（Exit）

想结束套利拿钱走人时：

平掉空单： 在合约界面，点击“平仓” (Close Position)，买入平空。你的保证金+利润回到了 USDT 余额。
卖出现货： 在现货界面，把那 0.166 ETH 卖成 USDT。
合体： 现在你手里全是 USDT 了（本金 + 赚到的资金费）。

做空合约(Shorting) / 空单(Short Position)

核心逻辑：先卖后买，赚跌幅。

假设我们现在的初始状态：

本金：1000 U。
当前 ETH 价格：100 U（为了方便计算，假设它很便宜）。

做空单：开 1 倍杠杆，做空 5 个 ETH。

什么是做空？ 实际上是你向交易所借了 5 个 ETH，然后按现在的价格（100 U）立马卖掉。
空单合约记录：“你欠交易所 5 个 ETH，但这 5 个 ETH 刚才卖了 500 U，钱押在柜台上”。

此时总资产状态：
实物： 5 个 ETH。
债务： -5 个 ETH。
现金/权益： 1000 U。

这时候，ETH 从 100 U 跌到了 50 U。

你要平仓（还债）。你要花钱买回 5 个 ETH。
现在 ETH 便宜了！买回 5 个只需要： $5 \text{ ETH} \times 50 \text{ U} = \mathbf{250 \text{ U}}$ 。
你当初卖那 5 个币可是卖了 500 U 呢！
交易所结算：柜台上的 500 U，扣掉你现在买币花的 250 U，剩下的都是你的利润。
合约盈利： $500 (\text{当初卖的钱}) - 250 (\text{现在买的钱}) = \mathbf{+250 \text{ U}}$ 。

-250 \text{ (现货亏的)} + 250 \text{ (合约赚的)} = \mathbf{0}

本金依然是 1000 U。

C++ 视角： 做空不是什么魔法，就是允许你的持仓数量（Position Quantity）为负数。

if (qty > 0): 多头（Long）。
if (qty < 0): 空头（Short）。
收益计算公式通用：PnL = (ExitPrice - EntryPrice) * Quantity。如果是空头（Quantity是负的），价格跌了（Exit < Entry），负负得正，你就赚钱了。

保证金 (Margin)

核心逻辑：押金。防止你亏了钱跑路。

为什么要它？
- 做空时，你是在“借”东西卖。如果苹果涨到了 100 块，你需要花 100 块才能买回来还给系统，但你手里只有当初卖的 10 块钱。中间的 90 块亏损谁出？系统怕你赔不起。
- 所以，开仓前，你必须先压一笔钱在桌子上，这就是保证金。
爆仓 (Liquidation)：
- 如果你亏损的钱快要把这笔押金亏光了，系统会强制替你平仓（强行买苹果还账），剩下的渣渣押金退给你。

C++ 视角： 这是一个风控阈值检查。 if (AccountBalance + UnrealizedPnL < MaintenanceMargin) { trigger_liquidation(); }

做空一定是合约吗？借现货可以吗？

可以向系统借现货做空。这叫做“杠杆交易” (Margin Trading)。

完全可以在币安/OKX 的“杠杆账户”里，借来 1 个真实的 BTC，然后立马卖掉。

但是，为什么在上面的“期现套利”策略里，建议用合约（Futures）做空，而不是用现货杠杆（Margin）做空呢？

这是“现金流方向”的问题：杠杆交易是你要付利息，做空合约是别人给你付利息。

方式 A：借现货做空 (Spot Margin Short)

这是最传统的做空方式，逻辑和现实世界一样。

借币： 你向交易所借 1 个 BTC。
- 代价： 你必须支付利息 (Interest)。就像你借钱要还利息一样，借币也要还币息。通常是按小时计费（年化 5% - 20% 不等）。
卖出： 把这 1 个 BTC 卖成 50,000 USDT。
归还： 等币跌到 40,000，你花 40,000 买回来还给交易所。
C++ 开发视角：
- API 属于 Margin 模块。
- 你需要显式调用 POST /margin/loan (借款) 和 POST /margin/repay (还款)。状态管理很麻烦。

方式 B：合约做空 (Futures Short)

这是金融衍生品。

开仓： 你和交易所签了一个“赌约”，赌价格会跌。你不需要真的去借那个币。
持有： 在持有期间，因为你让多头很不爽（多头希望涨），市场规则通常是“多头给空头付钱”来维持平衡（这就是资金费率）。
- 收益： 在币圈的大部分时间里（牛市或震荡市），空头是收钱的一方。
C++ 开发视角：
- API 属于 Futures 模块。
- 没有“借还”动作，只有 Open Position 和 Close Position。

做多永续合约的意义是什么？

“做多”是指做多永续合约吗？

不完全是。 “做多 (Long)”是一个泛型概念 (Generic Concept)。
在金融里，只要你的行为是 “买入持有，希望涨价”，都叫“做多”。具体体现在 C++ 代码里，取决于你操作的 Instrument_Type：

做多现货 (Long Spot): 真的买入了 BTC。
- Wallet.balance += 1 BTC;
做多期货/永续 (Long Futures/Perp): 签了一个赌涨的合约。
- Position.quantity = +1; (正数代表多头)
做多期权 (Long Call): 买入看涨期权。

在讨论的“资金费率”场景里：是的，指的是做多永续合约。因为只有永续合约的多头，才需要在资金费率为正时，给空头付利息。

做多永续合约的意义是什么？（为什么不直接买现货？）

既然要付利息给空头，还要冒爆仓风险，为什么那些多头不直接去买现货（Spot）拿着呢？现货还没利息成本。

答案只有一个核心：杠杆 (Leverage)。

这是赌徒和投机者的“致命诱惑”，也是金融市场存在的根本原因之一。

A. 资金利用率 (Capital Efficiency)

买现货 (Spot):
- 想买 10 个 BTC（假设 1个=5万U）。
- 必须真金白银拿出 50万 U。
买永续 (Perp Long):
- 可以开 10 倍杠杆。
- 只需要拿出 5万 U 作为保证金 (Margin)。
- 交易所借给你 45万，让你持仓 10 个 BTC。
- C++ 类比： 就像虚拟内存 (Virtual Memory)。你物理内存 (保证金) 只有 4GB，但你申请了 (malloc) 40GB 的地址空间。只要你不访问越界（不爆仓），程序就能跑。

B. 收益放大 (Amplification)

场景： BTC 涨了 10%。
现货玩家： 本金 50万 $\rightarrow$ 赚 5万。收益率 10%。
永续玩家 (10x)： 本金 5万 $\rightarrow$ 赚 5万。收益率 100% (翻倍)。

意义总结：

做多永续合约的人，是在用利息成本换取更低的资金占用和更高的收益倍数。他们相信币价上涨的速度会远远超过那点资金费率。

合约交割指的是什么？

实物交割（Physical Delivery）——一手交钱，一手交货

场景： 传统机构市场，或者石油、大豆期货。
流程：
1. 到期那一刻，停止交易。
2. 多头 (Long): 必须把全款打给交易所，然后你会收到真实的比特币（链上转账）。
3. 空头 (Short): 必须把真实的比特币转给交易所，然后收到全款。
C++ 逻辑： 涉及跨系统的资产转移，非常复杂。

现金交割（Cash Settlement）——只算差价，互不相欠

场景： 币圈 99% 的合约（包括永续，虽然永续不交割，但逻辑类似）。
流程：
1. 到期那一刻，系统看一眼现在的现货指数价格（比如 $50,500）。
2. 不管你当初是多少钱开的仓，系统强行按 $50,500 给你平仓。
3. 算总账：
  - 如果你是 $50,000 开的多单 $\rightarrow$ 交易所给你 $500 U。
  - 如果你是 $50,000 开的空单 $\rightarrow$ 交易所扣你 $500 U。
4. 销毁： 你的持仓被系统强制移除（Delete）。你没拿到币，只拿到了 USDT。

永续合约的“交割”

没有到期日
除非主动平仓，或者爆仓，否则永远持仓。
为了防止一直有人做多永续合约，导致合约价格飞速上涨，就让多头给做空的人利息以激励做空的人入场
反过来，防止一直有人做空永续合约，导致合约价格飞速下跌，就让空头给做多的人利息以激励做多的人入场

叫“利息”合适吗？

严格来说，不叫“利息”（Interest），业内术语叫“资金费用”（Funding Fee）。

虽然大家都习惯叫它“吃利息”，但它和银行贷款利息有本质区别：

银行利息 (Interest): 是基于时间和本金的借贷成本。是单向的（借款人付给银行）。
资金费用 (Funding Fee): 是基于价差 (Price Deviation) 的调节税。是双向的（多空互转）。

资金费率是怎么计算出来的？

公式通常由两部分组成：

FundingRate = \text{Interest Component} + \text{Premium Component}

A. 基础利率成分 (Interest Component)

这是固定的借贷成本。

通常设定得很低，比如每天 0.03% (每8小时 0.01%)。
这代表了计价货币（USDT）和标的货币（BTC）之间的借贷利率差。

B. 溢价成分 (Premium Component) —— 这才是核心！

这是为了“纠偏”用的动态部分。

\text{Premium} = \frac{\text{合约买卖中间价} - \text{现货指数价}}{\text{现货指数价}}

逻辑： 看看现在的合约比现货贵了百分之多少？
例子：
- 现货 BTC = 50,000
- 合约 BTC = 50,500 (多头太猛，贵了 1%)
- 那么溢价指数就是正的。

C. 最终结果 (Clamp Function)

交易所通常会用一个 Clamp 函数把费率限制在一定范围内（防止极端波动），但逻辑是：

价差越大 $\rightarrow$ 费率越高。
极端行情下，年化费率可以飙升到 100% 甚至 500%！

关键点： 这笔钱不是交给交易所的！交易所一分钱不拿，它只是把钱从多头的账户里划走，直接打入空头的账户。它是Peer-to-Peer的转账。

概念拆解：以 BTC-USDT 交易对为例

计价货币（Quote Currency）：USDT（钱）
标的货币（Base Currency）：BTC（货）

基础费率

当“做多” (Long) BTC/USDT 永续合约时，虽然你没感觉，但在金融逻辑上，你是在“借钱买货”：

你借入了 USDT（因为你开了杠杆，钱不够）。
你买入了 BTC（持有了仓位）。

那么问题来了：

借 USDT 需要付利息（假设利率 $I$ ）。
持有 BTC 理论上能赚利息（假设利率 $B$ ）。

基础费率 = USDT 的借贷利率 ( $I$ ) - BTC 的借贷利率 ( $B$ )

具体例子：
在加密货币市场，大家都很缺 USDT（用来买买买），所以 USDT 的利息通常比 BTC 高。

USDT 日利率 ( $I$ ): 0.06% (借钱很贵)
BTC 日利率 ( $B$ ): 0.03% (借币相对便宜)

计算结果：

差值 = 0.06\% - 0.03\% = \mathbf{0.03\%} \text{ (每天)}

这意味着：
哪怕现货和合约价格完全一样（没有溢价），多头依然要每天给空头付 0.03% 的钱。

为什么？ 因为多头占用了昂贵的 USDT 资源，而空头提供了这些资源。
C++ 常量： 这个值通常很稳定，你可以把它看作代码里的一个 const double BASE_RATE = 0.0001; (每8小时 0.01%)。

溢价费率

变量翻译

现货指数价 (Index Price):
- 定义： “真理的标准”。
- 来源： 币安不会只看自己家的现货价格，它会去抓取 Coinbase, Kraken, Bitstamp 等几家大交易所的现货价格，算一个加权平均值。
- 代码意义： Target_Value。
合约买卖中间价 (Impact Mid Price):
- 定义： “合约现在的价格”。
- 为什么不用最新成交价？ 因为成交价容易被操纵（只要一笔异常成交就能拉偏）。
- 算法： 它是看订单薄 (Orderbook) 的深度。比如取买单前 $10,000 的平均价和卖单前 $10,000 的平均价，算出来的中间值。
- 代码意义： Current_Value。

公式的物理含义

\text{溢价率} = \frac{\text{合约价} - \text{现货价}}{\text{现货价}}

这不就是在算：“现在的合约价格，比现货价格贵了百分之多少” 吗？

具体例子：
场景：大牛市，疯牛冲天。

现货指数价 (Index): 50,000 (外面理性的价格)。
合约中间价 (Mid): 50,050 (合约里大家杀红了眼，溢价买入)。

代入公式：

\frac{50,050 - 50,000}{50,000} = \frac{50}{50,000} = \mathbf{0.001}

转换成百分比： +0.1%
这意味着：

合约比现货贵了 0.1%。
系统判定：偏差较大，需要修正！
结果： 资金费率会在此刻飙升。多头（买方）必须按仓位价值的 0.1% 支付罚款给空头，迫使多头平仓，把价格压下来。

最终的 资金费率 (Funding Rate) 大致等于：

\text{资金费率} = \text{基础利率差 (0.01\%)} + \text{溢价率 (0.1\%)} = \mathbf{0.11\%}

基础利率差 (Interest Diff): 是底噪，平时大家不怎么关心，通常固定在 0.01% (每8小时)。
溢价率 (Premium Index): 是信号，决定了费率是正还是负，是高还是低。

50050 是怎么计算的

50,050 绝不是随便拍脑袋定的，也不是简单的 (买一 + 卖一) / 2。

如果是简单的 (Bid1 + Ask1) / 2，大户只需要用极小的资金挂一个假单，就能操纵整个市场的资金费率。为了防止这种情况，交易所使用的是 “深度加权中间价” (Impact Mid Price)。

核心概念：冲击金额 (Impact Notional)

交易所会规定一个“深度金额”，比如 10,000 USDT（或者 1 BTC）。它的含义是：“如果我现在立马用市价买入 10,000 U 的货，我的平均成交价是多少？”

这个平均成交价，才是真实的“市场公允价”。

算账现场：还原 Order Book

假设现在的合约盘口 (Order Book) 是这样的：

档位	价格 (Price)	挂单量 (Qty in BTC)	这一层的价值 (Value)
卖三 (Ask 3)	50,200	10.0	$502,000
卖二 (Ask 2)	50,100	0.1	$5,010
卖一 (Ask 1)	50,010	0.1	$5,001
买一 (Bid 1)	50,000	0.1	$5,000
买二 (Bid 2)	49,900	0.1	$4,990
买三 (Bid 3)	49,000	10.0	$490,000
虽然卖一卖得很便宜（50,010），但只有 0.1 个币。

第一步：计算“买入冲击价” (Ask Impact Price)

逻辑： 模拟拿 $10,000 去买币，看平均花多少钱。

吃掉卖一 (Ask 1):
- 价格: 50,010
- 买了: 0.1 BTC
- 花费: $5,001
- 还缺: $10,000 - $5,001 = $4,999
吃掉卖二 (Ask 2):
- 价格: 50,100
- 还需要买 $4,999 的货。
- 卖二有 0.1 BTC (价值 $5,010)，足够了。
- 实际买入: $4,999 / 50,100 $\approx$ 0.09978 BTC
- 花费: $4,999
计算加权平均价: $Ask\_Impact = \frac{\text{总花费}}{\text{总币数}} = \frac{10,000}{0.1 + 0.09978} = \frac{10,000}{0.19978} \approx \mathbf{50,055}$ (你看，比卖一价 50,010 要贵，因为你吃到了卖二)

第二步：计算“卖出冲击价” (Bid Impact Price)
逻辑： 模拟拿 $10,000 的币去卖，看平均卖多少钱。

吃掉买一 (Bid 1):
- 价格: 50,000
- 卖出: 0.1 BTC
- 获得: $5,000
- 还缺: $5,000
吃掉买二 (Bid 2):
- 价格: 49,900
- 卖二不够深，只有 $4,990。全吃掉！
- 卖出: 0.1 BTC
- 获得: $4,990
- 还缺: $10 (还需要再卖 $10)
吃掉买三 (Bid 3):
- 价格: 49,000
- 卖一点点就够了。
- 获得: $10
计算加权平均价:
这里为了简化计算，假设经过加权后算出： $\mathbf{50,045}$

第三步：算出最终的“合约中间价” (50,050)

合约中间价 = \frac{\text{买入冲击价} + \text{卖出冲击价}}{2}

= \frac{50,055 + 50,045}{2} = \mathbf{50,050}

总结：
之所以是 50,050 而不是 50,005 (简单的买一卖一平均)：是因为交易所认为“只买 1 块钱的任何价格都是不具备参考意义的”。
只有当你能真正拿出 10,000 U 还能成交的价格，才是用来计算资金费率的真实价格。这能防止有人挂一个 0.0001 BTC 的天价单来操纵费率。

永续合约这个怪胎，到底是合约的概念吗？

从传统金融学术定义来看，它根本不应该叫“期货 (Futures)”，它本质上是一个“掉期 (Swap)”。
更准确地说，它的学名应该叫 “永续掉期” (Perpetual Swap)。

为什么要发明这个？

在 2016 年之前，比特币只有传统的“交割合约”（比如 BTC-0930）。这就导致了一个巨大的用户体验痛点 (UX Pain Point)：

散户（Retail Traders）不想关心什么是“交割”，也不想关心什么是“移仓 (Roll-over)”。
每次合约到期，散户如果不手动把仓位卖掉，再买入下个月的合约，他的仓位就被强行结算了。
这导致流动性分散：一部分人在玩当周，一部分在玩下周，一部分在玩季度。

Arthur Hayes 的天才构想： “如果我们写一个 while(true) 的死循环合约，把所有人的流动性都集中在这里，永远不到期，然后用‘资金费率’来模拟交割，会怎么样？”

于是，XBTUSD 永续合约诞生了，它彻底改变了加密货币的历史，现在占据了 90% 以上的交易量。这是 Crypto 领域对传统金融最伟大的微创新之一（虽然也加剧了投机），它解决了流动性碎片化的问题。

它符合“交割合约”的概念吗？完全不符合。

传统期货 (Futures) 的定义： 双方约定在未来特定时间，以特定价格买卖资产。
- 核心约束：Time (时间)。时间到了，必须一手交钱一手交货（或者结算差价）。
永续合约 (Perpetual) 的定义： 双方交换基于资产价格的现金流。
- 核心约束：Price Convergence (价格收敛)。它没有时间终点，只有价格锚定。

从金融工程角度，它其实是“差价合约 (CFD)”的进化版。 但因为 CFD 在很多国家（如美国）是违法的或者受限的，而“期货”听起来更正规，且沿用了期货的“保证金”和“订单簿”机制，所以币圈习惯称之为“合约”。

明明不交割，为什么叫“合约”？

你觉得“不交割就不叫合约”，是因为你把“交割”理解为了“一次性的大结局”。

但在永续合约里，交割并没有消失，它只是被“微分”了。

对比：

A. 传统期货：积分模式 (Integral)

逻辑： 憋大招。
过程： 今天的价格和现货可能有巨大差异（比如现货 5万，期货 5万1）。
结局： 到了 3月31日 16:00 这一秒，强制让期货价格 = 现货价格。
交割： 一次性结算所有差价。

B. 永续合约：微分模式 (Differential)

逻辑： 小步快跑。
过程： 每 8 小时就是一个微型的“交割日”。
结局： 永远没有大结局。
交割： 资金费率 (Funding Fee) 就是交割！

这个概念非常重要： 当你每 8 小时支付或收到那一笔“资金费”的时候，你就在经历一次“微型交割”。

如果合约价格偏高，系统强行让多头吐出一部分钱给空头（模拟价格下跌的效果）。
如果合约价格偏低，系统强行让空头吐出一部分钱给多头（模拟价格上涨的效果）。

策略对比

策略类型	核心逻辑	风险特征	开发关注点
套利 (Arbitrage)	利用价差。例如：币安的BTC比OKX的贵，那边买这边卖；或者期货比现货贵（期现套利）。	极低风险，理论上无敞口。	速度 (Latency) 是生命线。抢单慢了就没利润了。
中性策略 (Market Neutral)	Beta = 0。通常指多空对冲。例如：做多强势币，做空弱势币；或者做市商（Market Making）。	风险较低，不赌大盘涨跌，赚取Alpha或流动性返佣。	系统稳定性。持仓通常很重，系统挂了无法对冲会造成巨大亏损。
CTA (Commodity Trading Advisor)	趋势跟踪为主。根据均线、动量等指标，判断大盘涨跌。CTA通常是有方向的（Long or Short），不是中性的。	风险较高，赌对了赚大钱，震荡市亏钱。	执行逻辑。通常不需要极低延迟，但要保证信号触发时必须成交。

国内商品期权套利

核心策略：期权平价套利（Put-Call Parity），俗称“合成期货套利”。

公式：

C - P + K = F

$C$ : 看涨期权价格 (Call)
$P$ : 看跌期权价格 (Put)
$K$ : 行权价 (Strike)
$F$ : 期货价格 (Future)
(注：国内无风险利率影响较小，暂且忽略贴现，实盘需加上)

正向套利：

信号：合成期货价格 > 真实期货价格。即 $(C-P+K)>F$
动作：卖贵的——卖出合成期货（即卖Call，买Put）；买便宜的，买入真实期货 F。
利润：锁定了价差，持有到期（或者等价差回归平仓）。

用郑州商品交易所（ZCE）的甲醇（Methanol, 代码MA）期货和期权来举例。假设合约单位是 10 吨/手。

第一阶段：发现机会（T0 时刻）——扫描 Bug

你的 C++ 程序通过 CTP 接口收到了以下行情（假设合约是 MA605，即26年5月到期）：

行权价 (K): 2500 元/吨
期货价格 (F): 2480 元/吨
Put (看跌期权) 价格 (P): 70 元/吨

程序内部计算：

合成期货价格 (Synthetic): $C - P + K = 60 - 70 + 2500 = \mathbf{2490}$
真实期货价格 (Future): $\mathbf{2480}$

价差为 10 元/吨。

结论：期货被低估了，期权组合被高估了。

第二阶段：锁死价差 (T1 时刻) —— 建立仓位

要做的动作是：“卖贵的，买便宜的”。

操作指令 (3 Legs)：

腿1 (Short Call): 卖出 1 手 MA605-C-2500 @ 60元。
- 现金流： 收入 +60。
- 状态： 义务方，如果不涨，白赚60；如果涨破2500，要赔钱。
腿2 (Long Put): 买入 1 手 MA605-P-2500 @ 70元。
- 现金流： 支出 -70。
- 状态： 权利方，跌了赚钱。
- (注：腿1+腿2 构成了“合成空头”，等效于以 2490 的价格卖出期货)
腿3 (Long Future): 买入 1 手 MA605 期货 @ 2480元。
- 现金流： 0 (期货主要占保证金，不计入即时盈亏，成本记录为2480)。
- 状态： 多头，涨了赚钱。

此时你的初始成本与潜在收益：

权利金净支出： $60 (\text{收}) - 70 (\text{付}) = \mathbf{-10 \text{ 元}}$ 。
你锁定的逻辑：
- 我在 2480 买了一手真期货。
- 我通过期权组合，相当于在 2500 的位置（经权利金调整后实际是 2490）建立了一个虚拟空单。
- 低买高卖，我已经锁定了 10 元的利润。

第三阶段：市场演变 (持有期间) —— 无论涨跌

现在可以去睡觉了，或者去写下一行代码。无论甲醇价格怎么剧烈波动，你的利润已经锁死。

我们来模拟两个极端场景，证明一下。

场景 A：暴涨！结算时甲醇涨到 3000 元

腿3 (期货多头):
- 2480 买的，现在 3000。
- 盈利： $3000 - 2480 = \mathbf{+520}$
腿2 (Put 多头):
- 涨到 3000 了，谁会按 2500 卖？废纸一张。
- 亏损： 买 Put 的权利金白付了。 $\mathbf{-70}$
腿1 (Call 空头):
- ⚠️ 对方要行权！对方要按 2500 买，你必须从市场花 3000 买来卖给他。
- 你的亏损 = $(2500 - 3000) = -500$ 。
- 别忘了你当初卖 Call 收了 60 权利金。
- 总亏损： $-500 + 60 = \mathbf{-440}$
算总账： $+520 \text{ (期货)} - 70 \text{ (Put)} - 440 \text{ (Call)} = \mathbf{+10 \text{ 元}}$

场景 B：暴跌！结算时甲醇跌到 2000 元

腿3 (期货多头):
- 2480 买的，现在 2000。
- 亏损： $2000 - 2480 = \mathbf{-480}$
腿1 (Call 空头):
- 跌成渣了，没人行权。
- 盈利： 卖的 Call 白赚权利金。 $\mathbf{+60}$
腿2 (Put 多头):
- ⚠️ 行权！我有权按 2500 卖，虽然市价只有 2000。
- 行权收益 = $2500 - 2000 = +500$ 。
- 减去当初买 Put 花的 70。
- 总盈利： $500 - 70 = \mathbf{+430}$
算总账： $-480 \text{ (期货)} + 60 \text{ (Call)} + 430 \text{ (Put)} = \mathbf{+10 \text{ 元}}$

第四阶段：变现

方式1：持有到期——强制收敛

这是最稳的。

到了到期日：假设最后结算价是 $S_t$ ；
期货自动平仓：交易所按 $S_t$ 结算盈亏；
期权自动行权：
1. 如果是实值期权（比如涨了，Call 是实值），交易所系统自动把 Call 仓位转变成期货空单，价格是 K（2500）。
2. 如果是虚值，自动作废。
对冲抵消：手里原本有一个期货多头，行权后如果又得到了一个期货空单，这两个单子在持仓中会自动对冲掉（Netting），变成现金。

提前平仓——赚“回归”的钱

通常我们不会持有到期（因为商品期货交割很麻烦，要增值税发票，还要求你是企业户）。
我们赚的是价差回归。

刚开始，价差是 10 元；
过了几天，临近到期，市场变得有效了，价差变成了 0 元（Call 和 Put 的价格回归正常）
操作：卖出期货，买入平仓 Call，卖出平仓 Put。
结果：因为价差消失了，平仓这一套动作赚到的钱就是当初锁定的那 10 元。

能赚多少

来算一笔实际的账（忽略手续费）：

单吨利润： 10 元/吨。
合约规模： 甲醇是 10 吨/手。
- 每套策略利润 = $10 \times 10 = \mathbf{100 \text{ 元}}$ 。
本金占用 (Margin)：
- 期货保证金：约 2500 (价格) * 10 (吨) * 10% (保证金率) = 2500 元。
- 期权保证金：卖方需要保证金，买方不需要。卖 Call 大概也需要 2500-3000 元。
- (注：国内交易所通常有组合保证金 (Portfolio Margin) 优惠，如果你同时持有对冲仓位，只收单边保证金)
- 假设一套组合占用 3000 元 资金。
收益率：
- 绝对收益：100 元。
- 资金占用：3000 元。
- 单次收益率： $100 / 3000 \approx \mathbf{3.3\%}$ 。

听起来不多？但这个 3.3% 可能是几周甚至几天的收益（取决于你离到期日多近）。如果一年能做 10 次这样的回归，年化就是 30%+ 的无风险收益。

结算规则

在股票期权里，行权是给你股票。但在商品期权里，行权给你的不是货，而是一个“期货持仓”。

为什么 Call 会变成“期货空单”？

首先，复习一下 Call（看涨期权）的定义：

Call = 这是一个权利，允许买方按价格 K 买入标的物。
你（套利者） = 你是 卖方 (Short Call)。你卖出了这个权利。

逻辑推导：

到了到期日，甲醇价格涨到了 3000。
对手方（买Call的人） 说：“我要行权！我要按合同价 2500 (K) 买入甲醇。”
交易所判定：你作为卖方，必须满足他。
你的义务：你必须“卖出”甲醇给他是吧？
在期货系统里：“卖出”这个动作，对应的状态就是“开立空单” (Open Short Position)。

结论：
因为你承诺了要“卖”，所以行权后，系统强行往你的账户里塞了一个“卖出的单子”，也就是期货空单。

为什么价格是 K (2500)？

这关乎“履约”的本质。

市场价 ( $S_t$ )：3000 元（现在的价格）。
行权价 ( $K$ )：2500 元（合同约定的价格）。

你当初卖 Call 的时候，签的合同就是：“不管未来涨到多少，我都愿意按 2500 卖给你。”
所以，当交易所把那个“期货空单”塞给你的时候，这个空单的开仓价 (Open Price) 必须写成 2500。
这意味着，虽然现在市场价是 3000，但你的账面上记录的是你在 2500 卖出的。

你的即时浮亏：
你手里有个 2500 的空单，市价是 3000。
浮动盈亏 = $2500 - 3000 = -500$ 。
（这 -500 就是你作为 Call 卖方即使亏损也要履行的义务）。

为什么会发生“对冲抵消”？价格一样吗？

这是最精彩的一步，也就是套利闭环的时刻。
在此刻（行权结算的一瞬间），你的账户里有两条记录同时存在。

左口袋：你原本持有的“期货多头” (Leg 3)

这是你一开始为了套利买进去的。

方向： 多单 (Long)
数量： 1 手
开仓价： 2480 元 (这是你 T0 时刻买入的成本)
当前市价： 3000 元
潜台词： “我在低位 2480 买了货。”

右口袋：系统刚塞给你的“期货空单” (Leg 1 行权结果)（期权合成空头）

这是刚才 Call 被行权后变成的。

方向： 空单 (Short)
数量： 1 手
开仓价： 2500 元 (这是按 K 结算的强制开仓价)
当前市价： 3000 元
潜台词： “我按约定在 2500 卖了货。”

为什么会抵消 (Netting)？

在期货交易系统（CTP）里，同一个合约（比如 MA605），如果你既有 +1 手（多），又有 -1 手（空），交易所的结算系统会在盘后（或即时）自动把它们对冲平仓。
这就好比：你左手拿着一个苹果（多单），右手欠别人一个苹果（空单）。系统直接说：“你把左手的苹果还给右手债主不就完了吗？”

算总账（你的利润从哪来）：

当这两笔单子“砰”的一声对冲消失时，你的利润就是两个“开仓价”的差值。

利润 = \text{空单开仓价} (2500) - \text{多单开仓价} (2480) = \mathbf{+20 \text{ 元}}

疑问：

“期货多头的价格和期货空单的价格在那时一样吗？”
- 不一样！ 这就是利润的来源！
- 你的多单成本是 2480。
- 你的空单履约价是 2500。
- 正是因为 2500 > 2480，你才赚到了中间的差价。
- 至于当时的市场价 (3000)，它只是一个背景板。它让你的多单赚了 520，让你的空单亏了 500，两者相减，依然是赚 20。市场价涨到 1万还是 1亿，你的利润永远是 20。

符号

定价与风控原子（The Engine）

用于描述单个期权的属性。

BS 公式（Black-Scholes Model）

一句话解释：这是个计算器函数，通过参数计算这个期权理论上应该值多少钱。

double BlackScholes(
    double S,      // 标的价格（Spot Price, e.g., BTC = 50000)
    double K,      // 行权价（Strike Price, e.g., 55000）
    double T,      // 剩余时间（Time to Maturity, e.g., 0.5 years）
    double r,      // 无风险利率（Risk-free Rate）
    double sigma   // 波动率（Volatility, 比如 50%）
);

用途：

找 Bug（套利）：如果函数算出 BS 价格是 $500，但市场上的卖一价是 $400。说明市场卖便宜了，现在可以买入套利。
反算波动率（Implied Volatility）：已知市场价格，反推 sigma 是多少。这是期权交易员最看重的指标。

Delta( $\Delta$ )——方向盘

一句话解释：价格敏感度。

标的（BTC）涨 1 块钱，我的期权涨多少钱？

定义： $\Delta = \frac{\partial \text{Price}}{\partial \text{Spot}}$
取值范围：
- Call: 0 到 1。 (平值约为 0.5)
- Put: -1 到 0。 (平值约为 -0.5)
- 期货: 永远是 1。

C++ 开发视角 (核心中的核心)：
“Delta Neutral (Delta 中性)”策略，代码逻辑就是：

double total_delta = (qty_call * delta_call) + (qty_put * delta_put) + (qty_future * 1.0);
if (abs(total_delta) > threshold)
{
    // Delta 偏离了，需要买卖期货来把 total_delta 归零
    Rebalance();
}

Delta = 0 意味着：不管 BTC 涨还是跌，只要幅度不大，我的账户总资产不变。

Gamma( $\Gamma$ )——“方向盘的抖动”/“加速度”

一句话解释：Delta

定义： $\Gamma = \frac{\partial \Delta}{\partial \text{Spot}} = \frac{\partial^2 \text{Price}}{\partial \text{Spot}^2}$
直观感受：
- Gamma 大：你的 Delta 及其不稳定。BTC 稍微动一下，Delta 就从 0.5 变成了 0.8。
- Gamma 小：Delta 很稳。

C++ 开发视角 (系统性能瓶颈)：

Gamma 越大 $\rightarrow$ 你需要越频繁地进行对冲（Rebalance） $\rightarrow$ 交易手续费越高，对系统的延迟要求越高。
“做空 Gamma” (Short Gamma): 类似于“卖出保险”。如果市场横盘不动，你赚翻了；如果市场暴涨暴跌，你会因为来不及对冲而亏死。

策略绩效指标（The Report Card）

用于描述整个账户 / 策略的属性。

Beta( $\beta$ )——随大流指数

一句话解释：你的策略和大盘（BTC）的相关性有多高？

定义：衡量系统性风险

例子：
- $\beta = 1$ : BTC 涨 10%，你的策略也涨 10%。(这就叫“囤币党”)
- $\beta = 2$ : BTC 涨 10%，你的策略涨 20%。(这就叫“2倍杠杆做多”)
- $\beta = 0$ : BTC 涨跌跟你没关系。哪怕 BTC 腰斩，你的净值曲线还是平稳向上的。(这就叫“中性策略” / Market Neutral)
开发目标： 公司的“中性策略”，目标就是把代码写成 Target Beta = 0。

Alpha( $\alpha$ )——真实手艺

一句话解释：剔除掉大盘涨跌的影响后，你凭本事赚了多少钱？

公式： $总收益=\alpha+(\beta \times 大盘收益)$
例子：
- 今年牛市，BTC 涨了 100%。
- 隔壁老王 (囤币): 资产翻倍。Beta = 1, Alpha = 0。他赚钱是因为风口来了（猪都能飞）。
- 你 (套利): 你的 Beta = 0。BTC 涨了 100% 跟你没关系，但你通过抓价差、赚资金费，资产涨了 30%。
- 这 30% 全是 Alpha。

开发视角： Alpha 是非常难赚的。它来自更快的代码 (Low Latency)、更聪明的算法或更低的手续费。老板给你发工资，就是买你的 Alpha。