加密货币做市商深度解析：从理论模型到实战思考

2026-03-10

本文试图回答一个根本问题：做市商到底赚的是什么钱？为什么有人愿意承担库存风险来提供流动性？从理论模型到实战思考，建立对做市商的完整认知。

一、历史的另一面：做市商从何而来？

1.1 金融市场最古老的职业

做市商 (Market Maker) 是金融市场最古老的职业之一。

1602 年，荷兰阿姆斯特丹证券交易所成立，世界上第一家证券交易所诞生那时，就有”挂牌交易商”在市场中双向报价，提供流动性。

做市商的本质：在市场中同时提供买价和卖价，承担价格波动风险，赚取买卖价差。

这听起来很简单？但背后有深刻的经济学原理。

1.2 为什么需要做市商？

想象一个没有做市商的市场：

你：我想买 1 个 BTC
交易所：等待有人愿意卖出...
1小时后...
交易所：有人报价了，42000 USDT
你：太贵了，我再等等...
3小时后...
交易所：有人愿意 41900 卖了
你：好，买入

问题：没有做市商，市场是间歇性的，交易效率极低。

做市商的价值：

1. 提供即时性 (Immediacy)：随时可以买卖
2. 提供流动性 (Liquidity)：缩小买卖价差
3. 承担风险 (Risk-bearing)：持有库存，价格波动时承担损失

1.3 Crypto 做市的独特历史

Crypto 市场的做市商生态是 2017 年之后才真正发展起来的。

2017: 交易所涌现，但做市商主要是个人
2018: 机构开始进入，Binance 崛起
2019: 专业做市商团队出现
2020: DeFi 兴起，链上做市新机会
2021: MEV 成为独立赛道
2022-至今: 机构化、竞争加剧、利润下降

为什么 Crypto 做市有机会？

• 交易所割裂 → 跨所套利
• 7×24 小时 → 机会不断
• 监管松散 → 创新空间大
• 波动性高 → 流动性溢价高

二、理论模型：做市的数学基础

2.1 库存模型 (Inventory Model)

这是做市商最经典的理论模型，由 Avellaneda 和 Stoikov 在 2008 年提出。

核心思想：做市商面临一个优化问题——如何在”赚取价差”和”承担库存风险”之间平衡？

模型假设：

• 订单簿价格遵循几何布朗运动：$dS_t = \mu S_t dt + \sigma S_t dW_t$
• 做市商可以设置买卖价差
• 库存有成本（融资成本、风险敞口）

目标函数：

其中 $a$ 是买价价差，$b$ 是卖价价差，$q_t$ 是库存。

2.2 最优价差公式 (Optimal Spread)

通过求解 HJB 方程，得到最优买卖价差：

其中：

• $\kappa$ 是风险厌恶系数
• $\sigma$ 是波动率
• $\lambda$ 是订单成交强度 (arrival rate)
• $q$ 是当前库存

直觉解释：

• 波动率 $\sigma$ 越大 → 价差越大（风险补偿）
• 库存 $q$ 越大 → 价差越大（需要更快清理库存）
• 成交强度 $\lambda$ 越大 → 价差越小（更快成交，不需要那么大补偿）

2.3 信息模型 (Information Model)

另一种理论视角：做市商赚的是信息不对称的钱。

模型假设：

• 部分交易者有私有信息 (informed traders)
• 做市商不知道真实价值，只能观察订单流
• 价差反映了”信息风险”

关键洞察：

做市商的利润，本质上是对”信息不对称的补偿”。

当市场有重大消息时（财报、宏观经济），价差会急剧扩大——因为做市商不知道谁有内幕信息。

2.4 两种模型的对比

现实中的做市商：两种利润来源都有，取决于市场状态。

三、数学推导：Optimal Quoting 详解

3.1 报价策略的形式化

做市商的报价可以形式化为：

买价 = S - δ/2  (调整库存)
卖价 = S + δ/2

其中 $S$ 是中间价，$\delta$ 是价差。

3.2 库存调整公式

当有库存时，做市商需要调整报价来”清理”库存：

def compute_optimal_spread(q, S, sigma, lambd, kappa):
    """
    q: 当前库存 (正=多头, 负=空头)
    S: 中间价
    sigma: 波动率
    lambd: 订单成交强度
    kappa: 风险厌恶系数
    """
    # 基础价差
    base_spread = kappa * np.sqrt(kappa * sigma**2 / (2 * lambd))
    
    # 库存调整
    inventory_adj = kappa * sigma * np.sqrt(2 * lambd / kappa) * q
    
    # 最优价差
    delta = base_spread + inventory_adj
    
    bid_price = S - delta / 2
    ask_price = S + delta / 2
    
    return bid_price, ask_price

3.3 关键参数的意义

3.4 实际应用

这个模型的局限：

1. 假设价格是几何布朗运动（实际市场不是）
2. 假设订单到达服从泊松分布（实际更复杂）
3. 没有考虑”逆向选择”（大单往往是知情交易者）

进阶模型需要考虑：

• 订单簿微观结构
• 知情交易者比例
• 融资成本
• 交易所费用

四、实操：代码实现

4.1 基础做市策略框架

class MarketMaker:
    def __init__(self, symbol, kappa=0.1, gamma=0.5):
        self.symbol = symbol
        self.kappa = kappa  # 风险厌恶系数
        self.gamma = gamma  # 波动率敏感度
        self.inventory = 0
        self.positions = []
        
    def compute_quotes(self, mid_price, sigma, lambda_):
        """计算最优报价"""
        # 基础价差
        base_spread = self.kappa * np.sqrt(
            self.gamma * sigma**2 / (2 * lambda_)
        )
        
        # 库存调整
        inv_adj = self.kappa * sigma * np.sqrt(
            2 * lambda_ / self.gamma
        ) * self.inventory
        
        delta = base_spread + inv_adj
        
        bid = mid_price - delta / 2
        ask = mid_price + delta / 2
        
        return bid, ask
    
    def on_trade(self, side, price, size):
        """成交回调"""
        if side == "buy":
            self.inventory += size
        else:
            self.inventory -= size
            
        self.positions.append({
            "side": side,
            "price": price,
            "size": size,
            "inventory": self.inventory
        })
    
    def compute_pnl(self):
        """计算盈亏"""
        if not self.positions:
            return 0
        
        total_pnl = 0
        for i, pos in enumerate(self.positions):
            # 简化计算：每笔交易的价差收益
            if i == 0:
                continue
            prev = self.positions[i-1]
            if pos["side"] != prev["side"]:
                # 对冲完成，计算价差收益
                total_pnl += abs(pos["price"] - prev["price"]) * pos["size"]
                
        return total_pnl

4.2 Binance API 实战

import binance.client
from binance.client import Client

class BinanceMarketMaker:
    def __init__(self, api_key, api_secret, symbol="BTCUSDT"):
        self.client = Client(api_key, api_secret)
        self.symbol = symbol
        
    def get_order_book(self, limit=20):
        """获取订单簿"""
        return self.client.get_order_book(symbol=self.symbol, limit=limit)
    
    def get_recent_trades(self, limit=100):
        """获取近期成交"""
        return self.client.get_recent_trades(symbol=self.symbol, limit=limit)
    
    def place_order(self, side, quantity, price=None):
        """下单
        side: BUY or SELL
        quantity: 数量
        price: 价格（限价单）
        """
        order_type = "LIMIT" if price else "MARKET"
        
        return self.client.create_order(
            symbol=self.symbol,
            side=side,
            type=order_type,
            timeInForce="GTC",
            quantity=quantity,
            price=price if price else None
        )
    
    def cancel_order(self, order_id):
        """撤单"""
        return self.client.cancel_order(
            symbol=self.symbol,
            orderId=order_id
        )
    
    def get_position(self):
        """获取持仓"""
        account = self.client.get_account()
        for balance in account["balances"]:
            if balance["asset"] == self.symbol.replace("USDT", ""):
                return float(balance["locked"]) + float(balance["free"])
        return 0

4.3 完整的策略循环

import time
import numpy as np

def run_strategy(maker, interval=1):
    """运行做市策略"""
    while True:
        try:
            # 1. 获取订单簿
            book = maker.get_order_book()
            bids = [(float(b[0]), float(b[1])) for b in book["bids"][:5]]
            asks = [(float(a[0]), float(a[1])) for a in book["asks"][:5]]
            
            # 2. 计算中间价和波动率
            mid_price = (bids[0][0] + asks[0][0]) / 2
            
            # 简化波动率计算（实际需要更多历史数据）
            sigma = mid_price * 0.02  # 2% 日波动率
            
            # 3. 计算报价
            lambda_ = 10  # 假设每秒10单
            bid, ask = maker.compute_quotes(mid_price, sigma, lambda_)
            
            # 4. 下单（实际需要处理成交回调）
            # maker.place_order("SELL", 0.001, ask)
            # maker.place_order("BUY", 0.001, bid)
            
            print(f"Mid: {mid_price:.2f}, Bid: {bid:.2f}, Ask: {ask:.2f}")
            
            time.sleep(interval)
            
        except Exception as e:
            print(f"Error: {e}")
            time.sleep(5)

五、哲学思考：做市商赚的是什么钱？

5.1 风险的定价

做市商的本质：对风险的定价。

当你作为做市商报价时，你实际上在说：

• “我愿意承担持有这个仓位的风险”
• “我的报价反映了这种风险的补偿”

问题是：这种风险应该如何定价？

传统金融学告诉我们：风险由波动率、流动性、融资成本决定。

但 Crypto 市场有独特因素：

• 交易所可能跑路 ( custody risk)
• 链上拥堵导致无法及时转账
• 项目方突然砸盘 (rug pull)
• 监管不确定性

5.2 信息不对称的新形式

在传统市场，做市商主要对抗”知情交易者”（有内幕消息的人）。

在 Crypto 市场，信息不对称有新的形式：

1. MEV：区块构建者有特权，可以”偷”走你的订单
2. 内盘 vs 外盘：交易所可能用做市商资金对倒
3. 项目方：项目方可能突然解锁代币砸盘

做市商的困境：

• 你永远不知道对手盘是否”知道一些你不知道的事”
• 价差是对这种不确定性的保险

5.3 市场效率与套利

一个深刻的悖论：

做市商的存在是为了让市场更有效，但做市商的利润来自于市场无效。

当市场出现明显无效（价差过大、跨所价差）时，做市商涌入，套利利润下降，市场变得更有效。

但这种”套利”是可持续的吗？

历史告诉我们：

• 1990s：统计套利年化 20%+
• 2000s：竞争加剧，利润率下降到 5-10%
• 2010s：高频交易入场，利润进一步压缩
• 2020s Crypto：还有机会，但窗口期越来越短

5.4 机械论 vs 适应论

做市策略有两派：

机械论：

• 基于固定数学模型
• 回测看起来很美
• 实盘可能失效（市场变了）

适应论：

• 基于观察和调整
• 更灵活
• 但需要持续人工干预

我的判断：

• 理论模型是必要的基础，但不是充分的
• 真正的优势来自于对模型的实践理解
• “纸上得来终觉浅，绝知此事要躬行”

六、个人洞察与建议

6.1 哪些策略还有机会？

6.2 哪些是坑？

1. 小市值币种做市：流动性差，容易被”钓”
2. 忽略融资成本：借 USDT 买币，利差可能吃掉利润
3. 过度依赖回测：历史业绩不代表未来
4. 忽视监管风险：某些策略可能违法

6.3 给新手的建议

1. 从资金费率套利开始：风险低，能理解市场
2. 学习理论模型：Avellaneda-Stoikov 是基础
3. 用小资金试错：不要一上来就 All in
4. 关注风险 > 关注收益：活下来比赚得快重要

6.4 一个反直觉的观点

做市商最大的敌人不是竞争对手，而是自己。

当你策略太激进，库存积累太多； 当你策略太保守，赚不到足够的价差； 当你太相信模型，市场突然变天。

最终，做市是一场与自己的博弈。

七、总结

本文从四个维度解析了做市商：

1. 历史维度：从 1602 年阿姆斯特丹交易所到 Crypto，做市商是最古老的金融职业之一

2. 理论维度：库存模型 (Avellaneda-Stoikov) 提供了最优报价的数学框架

3. 实操维度：提供了可运行的代码框架和 Binance API 示例

4. 哲学维度：做市商赚的是风险定价和信息不对称的钱

核心观点：

• 做市不是”无风险套利”，而是”风险定价”
• 理论模型是基础，但不是圣杯
• 竞争优势来自于对模型的深刻理解和持续适应

参考资料

1. Avellaneda, M., & Stoikov, S. (2008). High-frequency trading in a limit order book
2. Optimal Market Making - quantopian
3. Binance API Documentation
4. Paradigm - MEV and DeFi

本文是深度研究系列的第二篇，后续会继续深化具体策略