自成交保护机制¶

自成交指同一账户或实际控制关系账户组内的买卖订单相互匹配的行为

自动化交易策略：算法同时发送相同合约的多空双向订单，因系统延迟或逻辑漏洞导致匹配。
交易系统缺陷：如部分券商系统未对特定场景（如MOM账户同步发单）做自成交拦截。

自成交保护机制设计

主流交易所（如ICE、Nasdaq、中金所）的STP机制通常包含检查维度和处置策略两部分：

维度	说明
检查范围	按账户/客户号、MPID（会员ID）、Trader ID、自定义交易组等维度识别关联订单
处置策略	- Reject Taking Order (RTO)：拒绝新进入的主动订单 - Reject Resting Order (RRO)：撤销已挂单的被动订单（默认策略） - Reject Both Orders (RBO)：同时撤销双方订单 - 技术转让：将自成交转为内部划转（Nasdaq可选）

不同STP策略

以下是简化的订单撮合前STP检查逻辑示例，核心是通过账户ID和交易组ID识别关联订单，并执行对应策略：

// 1.
// STP检查逻辑：通过账户ID或交易组ID识别关联订单，结合合约、方向判断自成交风险。
// 2. 策略实现：
// ○ RTO：直接拒绝新订单；
// ○ RRO：撤销已有被动订单后允许新订单进入；
// ○ RBO：同时撤销双方订单。

#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

// 订单结构
struct Order {
  std::string order_id;
  std::string account_id;    // 账户ID（自成交检查核心）
  std::string trader_group;  // 自定义交易组（可选）
  std::string symbol;
  char side;  // 'B'买, 'S'卖
  double price;
  int quantity;
  bool is_active;
};

// 订单簿（模拟）
class OrderBook {
 private:
  std::unordered_map<std::string, Order> active_orders;  // 订单ID -> 订单

 public:
  // 添加订单到订单簿
  void add_order(const Order& order) { active_orders[order.order_id] = order; }

  // 检查是否存在关联的对手方订单（自成交风险）
  std::vector<Order> find_self_trade_orders(const Order& new_order) {
    std::vector<Order> result;
    for (auto& [id, order] : active_orders) {
      if (!order.is_active) continue;
      // 检查：相同合约 + 对手方 + 相同账户/交易组
      if (order.symbol == new_order.symbol && order.side != new_order.side &&
          (order.account_id == new_order.account_id ||
           order.trader_group == new_order.trader_group)) {
        result.push_back(order);
      }
    }
    return result;
  }

  // 撤销订单
  void cancel_order(const std::string& order_id) {
    if (active_orders.count(order_id)) {
      active_orders[order_id].is_active = false;
      std::cout << "订单 " << order_id << " 已撤销\n";
    }
  }
};

// STP策略枚举
enum class STPStrategy {
  RTO,  // 拒绝主动订单
  RRO,  // 撤销被动订单
  RBO   // 撤销双方订单
};

// STP处理器
class STPHandler {
 private:
  OrderBook& order_book;
  STPStrategy strategy;

 public:
  STPHandler(OrderBook& book, STPStrategy strat)
      : order_book(book), strategy(strat) {}

  // 执行STP检查，返回是否允许新订单进入
  bool check_and_handle(Order& new_order) {
    auto self_trades = order_book.find_self_trade_orders(new_order);
    if (self_trades.empty()) {
      return true;  // 无自成交风险，允许通过
    }

    // 根据策略处置
    switch (strategy) {
      case STPStrategy::RTO:
        std::cout << "自成交风险：拒绝新订单 " << new_order.order_id << "\n";
        return false;

      case STPStrategy::RRO:
        for (auto& resting_order : self_trades) {
          order_book.cancel_order(resting_order.order_id);
        }
        std::cout << "自成交风险：撤销被动订单，允许新订单 "
                  << new_order.order_id << " 进入\n";
        return true;

      case STPStrategy::RBO:
        for (auto& resting_order : self_trades) {
          order_book.cancel_order(resting_order.order_id);
        }
        std::cout << "自成交风险：撤销双方订单，拒绝新订单 "
                  << new_order.order_id << "\n";
        return false;
    }
    return true;
  }
};

// 测试示例
int main() {
  OrderBook book;
  STPHandler handler(book, STPStrategy::RRO);  // 使用RRO策略

  // 添加一个被动卖单
  Order resting_order{"O001", "A1001", "TG01", "IF2603", 'S', 4500.0, 10, true};
  book.add_order(resting_order);

  // 新订单：同一账户的买单（自成交风险）
  Order new_order{"O002", "A1001", "TG01", "IF2603", 'B', 4500.0, 5, true};

  // 执行STP检查
  if (handler.check_and_handle(new_order)) {
    book.add_order(new_order);
  }

  return 0;
}