BitMEX Market Maker源码深度剖析：OrderManager核心算法与订单收敛逻辑

【免费下载链接】sample-market-maker Sample BitMEX Market Making Bot 项目地址: https://gitcode.com/gh_mirrors/sam/sample-market-maker

BitMEX Market Maker是一款开源的做市机器人项目，旨在为BitMEX交易所提供自动化的订单管理功能。本文将深入解析其核心组件OrderManager的算法实现与订单收敛逻辑，帮助开发者理解做市策略的底层机制。

OrderManager核心架构解析

OrderManager类位于market_maker/market_maker.py文件中，是整个项目的核心控制器。其主要职责包括：

• 维护与交易所的连接（通过ExchangeInterface）
• 管理订单生命周期（创建、修改、取消）
• 实现订单收敛算法
• 监控市场状态与风险控制

初始化流程

OrderManager的初始化过程在__init__方法中完成，主要包括：

1. 创建交易所接口实例，建立与BitMEX的连接
2. 注册程序退出处理函数，确保异常退出时能取消所有订单
3. 验证订单大小设置是否符合交易所的合约规格
4. 初始化订单状态并执行重置操作

关键代码片段展示了初始化时的参数验证逻辑：

if settings.ORDER_START_SIZE % self.instrument['lotSize'] != 0 or settings.ORDER_START_SIZE < self.instrument['lotSize']:
    print(f"Invalid ORDER_START_SIZE, must be divisible by lotSize of {self.exchange.symbol} instrument")
    print(f"Setting ORDER_START_SIZE to lotSize of {self.exchange.symbol}: {self.instrument['lotSize']}")
    settings.ORDER_START_SIZE = self.instrument['lotSize']

订单生成算法详解

OrderManager通过place_orders方法生成买卖订单列表，采用"从外到内"的订单创建策略。这种设计的优势在于当内侧订单被成交后，只需要创建新的内侧订单，而不需要修改所有现有订单。

价格偏移计算

get_price_offset方法实现了核心的价格计算逻辑，根据配置的间隔参数（INTERVAL）生成一系列价格档位：

def get_price_offset(self, index):
    """Given an index (1, -1, 2, -2, etc.) return the price for that side of the book.
       Negative is a buy, positive is a sell."""
    # Maintain existing spreads for max profit
    if settings.MAINTAIN_SPREADS:
        start_position = self.start_position_buy if index < 0 else self.start_position_sell
        # First positions (index 1, -1) should start right at start_position, others should branch from there
        index = index + 1 if index < 0 else index - 1
    else:
        # Offset mode: ticker comes from a reference exchange and we define an offset.
        start_position = self.start_position_buy if index < 0 else self.start_position_sell

        # If we're attempting to sell, but our sell price is actually lower than the buy,
        # move over to the sell side.
        if index > 0 and start_position < self.start_position_buy:
            start_position = self.start_position_sell
        # Same for buys.
        if index < 0 and start_position > self.start_position_sell:
            start_position = self.start_position_buy

    return math.toNearest(start_position * (1 + settings.INTERVAL) ** index, self.instrument['tickSize'])

订单数量计算

prepare_order方法根据配置生成订单数量，支持两种模式：固定步长递增或随机订单大小：

def prepare_order(self, index):
    """Create an order object."""
    if settings.RANDOM_ORDER_SIZE is True:
        quantity = random.randint(settings.MIN_ORDER_SIZE, settings.MAX_ORDER_SIZE)
        # Respect lot size
        quantity = round(quantity / settings.ORDER_STEP_SIZE) * settings.ORDER_STEP_SIZE
    else:
        quantity = settings.ORDER_START_SIZE + ((abs(index) - 1) * settings.ORDER_STEP_SIZE)

    price = self.get_price_offset(index)
    return {'price': price, 'orderQty': quantity, 'side': "Buy" if index < 0 else "Sell"}

订单收敛逻辑：核心算法解析

订单收敛（converge_orders）是OrderManager最核心的功能，实现了当前订单簿状态与目标订单状态的智能同步。这一过程通过四个步骤完成：

1. 匹配现有订单：将现有订单与目标订单进行匹配
2. 标记需修改订单：识别需要调整价格或数量的订单
3. 标记需取消订单：识别不再需要的订单
4. 标记需创建订单：识别需要新增的订单

收敛算法实现

converge_orders方法的核心代码如下：

def converge_orders(self, buy_orders, sell_orders):
    """Converge the orders we currently have in the book with what we want to be in the book.
       This involves amending any open orders and creating new ones if any have filled completely.
       We start from the closest orders outward."""

    tickLog = self.exchange.get_instrument()['tickLog']
    to_amend = []
    to_create = []
    to_cancel = []
    buys_matched = 0
    sells_matched = 0
    existing_orders = self.exchange.get_orders()

    # Check all existing orders and match them up with what we want to place.
    # If there's an open one, we might be able to amend it to fit what we want.
    for order in existing_orders:
        try:
            if order['side'] == 'Buy':
                desired_order = buy_orders[buys_matched]
                buys_matched += 1
            else:
                desired_order = sell_orders[sells_matched]
                sells_matched += 1

            # Found an existing order. Do we need to amend it?
            if desired_order['orderQty'] != order['leavesQty'] or (
                    # If price has changed, and the change is more than our RELIST_INTERVAL, amend.
                    desired_order['price'] != order['price'] and
                    abs((desired_order['price'] / order['price']) - 1) > settings.RELIST_INTERVAL):
                to_amend.append({'orderID': order['orderID'], 'orderQty': order['cumQty'] + desired_order['orderQty'],
                                 'price': desired_order['price'], 'side': order['side']})
        except IndexError:
            # Will throw if there isn't a desired order to match. In that case, cancel it.
            to_cancel.append(order)

    # Handle remaining orders to create
    while buys_matched < len(buy_orders):
        to_create.append(buy_orders[buys_matched])
        buys_matched += 1

    while sells_matched < len(sell_orders):
        to_clientrate.append(sell_orders[sells_matched])
        sells_matched += 1

订单操作优化

算法通过批量处理订单操作来减少API调用次数，提高效率：

• 对于价格或数量变化超过阈值（RELIST_INTERVAL）的订单进行修改
• 对超出目标数量的现有订单进行取消
• 对未匹配的目标订单进行创建

这种增量更新策略显著降低了交易所API的调用频率，同时确保订单簿状态能够快速收敛到目标状态。

风险控制机制

OrderManager内置了多重风险控制机制，保护用户资金安全：

仓位限制检查

通过long_position_limit_exceeded和short_position_limit_exceeded方法实现仓位限制检查：

def long_position_limit_exceeded(self):
    """Returns True if the long position limit is exceeded"""
    if not settings.CHECK_POSITION_LIMITS:
        return False
    position = self.exchange.get_delta()
    return position >= settings.MAX_POSITION

市场状态检查

在每次订单更新前，通过sanity_check方法验证市场状态：

def sanity_check(self):
    """Perform checks before placing orders."""
    # Check if OB is empty - if so, can't quote.
    self.exchange.check_if_orderbook_empty()

    # Ensure market is still open.
    self.exchange.check_market_open()

    # Get ticker, which sets price offsets and prints some debugging info.
    ticker = self.get_ticker()

    # 价格合理性检查
    if self.get_price_offset(-1) >= ticker["sell"] or self.get_price_offset(1) <= ticker["buy"]:
        logger.error("Sanity check failed, exchange data is inconsistent")
        self.exit()

自定义策略扩展

项目支持通过继承OrderManager实现自定义策略。如market_maker/custom_strategy.py所示：

from market_maker.market_maker import OrderManager

class CustomOrderManager(OrderManager):
    def place_orders(self):
        # 自定义订单生成逻辑
        buy_orders = []
        sell_orders = []
        
        # 实现自定义策略...
        
        self.converge_orders(buy_orders, sell_orders)

order_manager = CustomOrderManager()

运行流程与生命周期管理

OrderManager的运行流程由run_loop方法控制：

def run_loop(self):
    while True:
        sys.stdout.write("-----\n")
        sys.stdout.flush()

        self.check_file_change()
        sleep(settings.LOOP_INTERVAL)

        # 检查连接状态
        if not self.check_connection():
            logger.error("Realtime data connection unexpectedly closed, restarting.")
            self.restart()

        self.sanity_check()  # 市场状态检查
        self.print_status()  # 打印当前状态
        self.place_orders()  # 生成并收敛订单

程序还实现了文件变更监控功能，当配置或策略文件修改时自动重启，方便开发调试：

def check_file_change(self):
    """Restart if any files we're watching have changed."""
    for f, mtime in watched_files_mtimes:
        if getmtime(f) > mtime:
            self.restart()

总结

BitMEX Market Maker的OrderManager通过精妙的设计实现了高效的订单管理与做市策略。其核心优势在于：

1. 智能订单收敛：通过增量更新减少API交互，提高效率
2. 灵活的订单生成：支持多种订单定价与数量策略
3. 完善的风险控制：多重检查机制保障交易安全
4. 易于扩展：通过继承机制支持自定义策略

开发者可以通过修改配置文件market_maker/settings.py调整做市参数，或通过继承OrderManager实现复杂的自定义策略。项目的模块化设计使得代码维护和功能扩展变得简单直观。

要开始使用该项目，只需克隆仓库并安装依赖：

git clone https://gitcode.com/gh_mirrors/sam/sample-market-maker
cd sample-market-maker
pip install -r requirements.txt

然后根据BitMEX交易所的要求配置API密钥，即可启动做市机器人。

【免费下载链接】sample-market-maker Sample BitMEX Market Making Bot 项目地址: https://gitcode.com/gh_mirrors/sam/sample-market-maker