原ft项目做得太垃圾，已废弃。新框架xyts功能完善、稳定、延迟低，已经实盘验证，稳定运行多年，合作可直接联系作者本人。

xyts sdk已经发布在https://github.com/xywanz/xyts-strategy-sdk

一同发布的还有一个可以跑起来的策略demo，里面放了一天的行情数据，可以回测，https://github.com/xywanz/strategy

xyts

本篇主要介绍如何在xyts上进行策略开发，并附带介绍一些xyts的可扩展模块

开发环境

$ lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 22.04.3 LTS
Release:	22.04
Codename:	jammy

g++ --version
g++ (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0

说明：

支持g++, clang++, Apple clang++，推荐版本
- g++ >= 11.3.0
- clang++ >= 18
提供数据推送的接口，正在开发监控界面，有需要也可自己对接
有丰富的单元测试，确保系统正确无误地运行
暂时只支持使用C++编写策略

简介

策略的开发主要涉及到三个核心的类型

xyts::strategy::Strategy
xyts::strategy::StrategyContext
xyts::strategy::StrategyParamManager

Strategy包含了一系列的虚回调函数，需要用户去继承并将策略逻辑实现在相应的回调函数里

StrategyContext是策略运行的上下文环境，用于策略跟实盘交易/回测环境的交互，提供了下单、撤单、订阅行情、查询成交、查询持仓、添加定时器等策略需要用到的功能

StrategyParamManager用于策略读写参数，并支持运行时从外部对策略参数进行修改、实时落地同步到json文件。用户需要按照指定格式为每个策略编写一个json文件，该文件用于定义策略参数，然后用脚本strategy_param_mgr_generator.py从该配置生成.h头文件，该头文件提供了策略访问策略参数的接口

一些特性：

回测和实盘使用同一套策略代码，一次编译生成的策略动态库既可用于回测，也可用于实盘
实盘采用多进程架构，通过共享内存传递消息，各个策略可随时启停。策略之间互不影响，但可通过消息队列来订阅发布消息

一些缺陷：

为了不增加额外的负担，StrategyContext提供的函数都不是线程安全的，只能够用在策略构造函数、析构函数以及各类回调（包括通过ctx添加的定时器）中。如果需要使用多线程，建议通过线程安全的消息队列传递消息，策略通过定时任务定期处理消息
回测程序并不能很好地支持用户自己创建的多线程，需要用户自己来保证其余线程时间上的同步

典型策略程序示例

以一个常见的跨期套利策略为例，来说明策略的整体开发流程。这个策略并不包含错误处理，我们假设订单最后都能成功报出去。假设我们的策略名字叫做strategy_spread_arb

首先创建策略的配置文件strategy_spread_arb.json，我们在配置文件中定义了四个策略参数，分别是套利两条腿的合约名、套利上下轨的位置

{
  "leg1_instr": {
    "type": "string",
    "value": "FUT_SHFE_rb-202405"
  },
  "leg2_instr": {
    "type": "string",
    "value": "FUT_SHFE_rb-202410"
  },
  "upper_line": {
    "type": "double",
    "value": 30
  },
  "lower_line": {
    "type": "double",
    "value": 20
  }
}

接着用strategy_param_mgr_generator.py来生成C++的策略参数访问接口

python3 strategy_param_mgr_generator.py strategy_spread_arb.json

运行后会在当前目录生成strategy_spread_arb.h，该文件内容如下

// This file is generated from strategy_spread_arb.json. DO NOT EDIT!
#pragma once

#include <string>
#include <vector>

#include "xyts/strategy/strategy_param_manager.h"

class StrategySpreadArbParamManager final : public ::xyts::strategy::StrategyParamManager {
 public:
  explicit StrategySpreadArbParamManager(const std::filesystem::path& param_path): StrategyParamManager(param_path) {
    leg1_instr = CheckAndGetParamValue<std::string>("leg1_instr");
    leg2_instr = CheckAndGetParamValue<std::string>("leg2_instr");
    upper_line = CheckAndGetParamValue<double>("upper_line");
    lower_line = CheckAndGetParamValue<double>("lower_line");
  }

  const char* nameof_leg1_instr() const { return "leg1_instr"; }
  const std::string& get_leg1_instr() const { return leg1_instr; }
  void set_leg1_instr(const std::string& _leg1_instr) {
    leg1_instr = _leg1_instr;
    json_params_["leg1_instr"]["value"] = _leg1_instr;
  }

  const char* nameof_leg2_instr() const { return "leg2_instr"; }
  const std::string& get_leg2_instr() const { return leg2_instr; }
  void set_leg2_instr(const std::string& _leg2_instr) {
    leg2_instr = _leg2_instr;
    json_params_["leg2_instr"]["value"] = _leg2_instr;
  }

  const char* nameof_upper_line() const { return "upper_line"; }
  const double get_upper_line() const { return upper_line; }
  void set_upper_line(const double _upper_line) {
    upper_line = _upper_line;
    json_params_["upper_line"]["value"] = _upper_line;
  }

  const char* nameof_lower_line() const { return "lower_line"; }
  const double get_lower_line() const { return lower_line; }
  void set_lower_line(const double _lower_line) {
    lower_line = _lower_line;
    json_params_["lower_line"]["value"] = _lower_line;
  }

  void Update(const nlohmann::json& update_json) final {
    if (ContainsParam(update_json, "leg1_instr")) {
      auto value = GetParamValue<std::string>(update_json, "leg1_instr");
      set_leg1_instr(value);
    }
    if (ContainsParam(update_json, "leg2_instr")) {
      auto value = GetParamValue<std::string>(update_json, "leg2_instr");
      set_leg2_instr(value);
    }
    if (ContainsParam(update_json, "upper_line")) {
      auto value = GetParamValue<double>(update_json, "upper_line");
      set_upper_line(value);
    }
    if (ContainsParam(update_json, "lower_line")) {
      auto value = GetParamValue<double>(update_json, "lower_line");
      set_lower_line(value);
    }
  }

 private:
  template <class T>
    T CheckAndGetParamValue(const std::string& param_name) {
    if (!ContainsParam(json_params_, param_name)) {
      throw std::runtime_error("Parameter '" + param_name + "' does not exist");
    }
    return GetParamValue<T>(json_params_, param_name);
  }

  static bool ContainsParam(const nlohmann::json& json, const std::string& param_name) {
    return json.contains(param_name) && json[param_name].contains("value");
  }

  template <class T>
  static T GetParamValue(const nlohmann::json& json, const std::string& param_name) {
    return json[param_name]["value"].get<T>();
  }

  std::string leg1_instr;
  std::string leg2_instr;
  double upper_line = 0;
  double lower_line = 0;
};

我们在策略代码中可以通过StrategySpreadArbParamManager这个类来访问刚刚我们在json文件中定义的4个参数。这个类的实例是如何构造出来的我们不需要管，因为StrategyContext会自动帮我们构造好，我们只需要知道如何使用即可，这个会在策略实现部分继续说明。

接下来我们看看策略的实现部分，创建策略源文件strategy_spread_arb.cpp

// 以下三个头文件中包含的分别是我们刚刚提到的三个核心类型
#include "xyts/strategy/strategy.h"
#include "xyts/strategy/strategy_context.h"
#include "strategy_spread_arb_param_manager.h"
// 日志库
#include "xyts/core/log.h"
// 合约表
#include "xyts/core/contract_table.h"
// 项目里还有很多实用的库
// #include "xyu/datetime.h"  Python-like datetime库
// ...

using namespace xyts;
using namespace xyts::strategy;

class StrategySpreadArb final : public Strategy {
 public:
  // 构造函数必须如下所示，只传入一个StrategyContext指针。
  // 我们需要将ctx保存下来，用于接下来与交易环境进行交互。
  // 构造函数就相当于策略的初始化，构造策略时策略上下文已经完成了初始化。
  explicit StrategySpreadArb(StrategyContext* ctx);

  ~StrategySpreadArb();

  void OnDepth(const DepthData& depth) final;

  // 订单状态有更新
  void OnOrder(const OrderResponse& order) final;

 private:
  StrategyContext* ctx_;                  // 用于保存StrategyContext
  StrategySpreadArbParamManager* param_;  // 策略参数

  ContractPtr leg1_contract_;
  ContractPtr leg2_contract_;

  double leg1_mid_price_ = std::numeric_limits<double>::quiet_NaN();
  double leg2_mid_price_ = std::numeric_limits<double>::quiet_NaN();
};

StrategySpreadArb::StrategySpreadArb(StrategyContext* ctx)
    : ctx_(ctx),
      param_(ctx->GetDerivedParamManager<StrategySpreadArbParamManager>()),
      leg1_contract_(ContractTable::GetByInstrument(param_->get_leg1_instr())),
      leg2_contract_(ContractTable::GetByInstrument(param_->get_leg2_instr())) {
  if (!leg1_contract_) {
    throw std::runtime_error("Unknown leg1 " + param_->get_leg1_instr());
  }
  if (!leg2_contract_) {
    throw std::runtime_error("Unknown leg2 " + param_->get_leg2_instr());
  }

  // 订阅leg1和leg2的行情和持仓信息
  ctx_->SubscribeMarketData({leg1_contract_->instr, leg2_contract_->instr});
}

StrategySpreadArb::~StrategySpreadArb() {
  LOG_INFO("Strategy {} stopped", ctx_->GetStrategyName());
  // 可以在析构函数中保存策略的一些状态到文件中，用于下次启动时加载
  // do sth.
}

void StrategySpreadArb::OnDepth(const DepthData& depth) {
  // 竞价阶段bid[0]==ask[0]，我们不在该阶段交易
  if (std::abs(depth.bid[0] - depth.ask[0]) < 1e-6) {
    return;
  }

  // 这里没有考虑bid或ask没有挂单的情况，假设bid和ask价格都存在
  if (depth.contract_id == leg1_contract_->contract_id) {
    leg1_mid_price_ = (depth.bid[0] + depth.ask[0]) / 2;
  } else {
    // 为了简单，只在收到leg2行情的时候计算spread
    leg2_mid_price_ = (depth.bid[0] + depth.ask[0]) / 2;
    // leg1还没收到行情，无法计算spread
    if (std::isnan(leg1_mid_price_)) {
      return;
    }
    double spread = leg1_mid_price_ - leg2_mid_price_;
    auto pos = ctx_->GetLogicalPosition(leg1_contract_->contract_id);
    if (spread >= param_->get_upper_line()) {
      // 超过上轨，如果仓位还没满做空spread
      if (pos.volume > -1) {
        ctx_->Buy(leg2_contract_->contract_id, 1, OrderType::kMarket, 0);
        ctx_->Sell(leg1_contract_->contract_id, 1, OrderType::kMarket, 0);
      }
    } else if (spread <= param_->get_lower_line()) {
      // 跌破下轨，如果仓位还没满则做多spread
      if (pos.volume < 1) {
        ctx_->Sell(leg2_contract_->contract_id, 1, OrderType::kMarket, 0);
        ctx_->Buy(leg1_contract_->contract_id, 1, OrderType::kMarket, 0);
      }
    }
  }
}

void StrategySpreadArb::OnOrder(const OrderResponse& order) {
  const auto* contract =
      order.contract_id == leg1_contract_->contract_id ? leg1_contract_ : leg2_contract_;
  LOG_INFO("{} {}{} {} {} px:{:.2f} fill/total:{}/{} order_id:{}", contract->instr, order.direction,
           order.position_effect, order.status, order.error_code, order.price,
           order.accum_trade_volume, order.original_volume, order.order_id);

  if (order.current_trade_volume > 0) {
    LOG_INFO("{} {}{} {:.2f}@{}", contract->instr, order.direction, order.position_effect,
             order.current_trade_price, order.current_trade_volume);
  }
}

// 导出策略符号，使得能通过动态库的形式加载
EXPORT_STRATEGY(StrategySpreadArb);

编写完后将策略编译成动态库即可被实盘或回测环境加载

策略程序编译

策略程序回测

我们使用backtester程序对策略进行回测

我们需要准备以下数据或程序用于回测，目录结构如下

├── bin
│   └── backtester
├── conf
│   └── backtester.yaml
├── data
├── lib
│   ├── libstrategy_spread_arb.so
│   └── libxyts.so
└── log

我们在conf下创建backtester.yaml，并填入如下配置

strategies:
  - strategy_name: strategy_spread_arb
    strategy_so: ../lib/libstrategy_spread_arb.so  # 编译好的策略动态库
    strategy_param_file: ../conf/strategy_spread_arb.json

# 回测范围为[begin_date, end_date]之间的所有交易日
backtest_period:
  begin_date: 2024-01-01
  end_date: 2024-01-15

strategy_start_time:
  night: '20:55'  # 夜盘策略启动时间，默认值20:50
  day: '08:55'  # 日盘策略启动时间，默认值08:50

sessions:
# 夜盘交易时段
  night:
    - begin_time: '20:59'
      end_time: '23:01'
  # 日盘交易时段
  day:
    - begin_time: '09:00'
      end_time: '10:15'
    - begin_time: '10:30'
      end_time: '11:30'
    - begin_time: '13:30'
      end_time: '15:01'

initial_capital: 100000000  # 起始资金

# 合约表路径
contract_files:
  - ../data/contracts_%Y%m%d.csv

holiday_directory: ../data/holiday  # xydata交易日历路径

# 行情数据配置
data_feed:
  type: csv_data_feed
  data_directory: ../data/depth  # xydata csv格式的快照数据目录

matching_engine:
  type: emu_matching_engine  # emu为排队撮合

# 手续费配置
fee:
  - instr: 'FUT_SHFE_rb.+?'
    type: percentage
    rate: 0.0001

# 滑点
slippage: 0

准备回测需要用到的交易日历、快照以及合约表数据，放在data目录中。数据如何组织以及数据的格式请参考xydata

准备好数据后，进入到bin目录中，执行命令启动回测

nohup ./backtester ../conf/backtester.yaml ../log/backtester.log 2>&1 &

日志会输出到log目录下，回测完成后会将回测结果输出到backtest_stats.json

策略实盘上线

实盘用strategy_loader来加载我们编译好的策略动态库。

在启动策略前需要启动以下进程：

trader
market_center
各个data_feed程序用于收行情（只需要在market_center之后启动，与策略之间的启动顺序没有要求，而且可以随时启停），如果有多个源的话可以启动多个以提高可靠性

配置好交易系统及策略后，可以在bin目录下执行以下命令启动交易系统

# 生成合约表
./query_contracts ../log/trader.log ../conf
# 一键启动trader、market_center以及各个行情程序
./restart.sh
# 启动策略
python3 manager.py start_strategy strategy_spread_arb_01

Strategy基类

策略是由事件驱动，策略目前支持以下几种事件

Depth
Order
Message
ParamUpdate
Command

OnDepth

如果策略在初始化时订阅了一些合约，那么这些合约的行情更新时会通过OnDepth通知策略，策略可在OnDepth中实现策略的主要逻辑

OnOrder

策略订单的状态发生任何变动时，都会通过OnOrder通知策略，具体的变动包括

订单被XYTS风控拒绝
订单被XYTS接收
订单被柜台/交易所拒绝
订单被交易所接收
订单被撤销
订单发生了成交（每有一笔成交都会通知一次）

OnParamUpdate

策略参数由外部进行修改时，会由该回调通知，消息中只包含了那些被修改的参数。假如策略的upper_line和lower_line两个参数被外部修改了，消息格式如下

{
  "upper_line": {
    "value": 32
  },
  "lower_line": {
    "value": 22
  }
}

OnMessage

如果策略在初始化时调用了SubscribeTopics订阅了一些topics的话，如果该topics中有策略感兴趣数据进来，会通过OnMessage通知策略，策略需要自行对数据进行解包

也可以通过OnMessage接收来自data_feed_api的自定义行情

OnCommand

策略收到自定义控制命令

StrategyContext用法说明

AddTimeout & AddPeriodicCallback

XYTS内置高精度定时器功能，可以在策略构造时或任意回调里使用，并支持取消。该功能完美支持回测。

单次的超时回调

// 500微秒后执行1次
auto timer_id = ctx->AddTimeout(std::chrono::microseconds{500}, [this](auto) {
  // do sth.
});
// 如果不想在500微秒后执行了，可以移除定时器
ctx->RemoveTimer(timer_id);
// 可以支持多种时间类型
ctx->AddTimeout(std::chrono::milliseconds{1}, [this](auto) {});
ctx->AddTimeout(std::chrono::seconds{1}, [this](auto) {});

定期执行的回调

// 每500微秒执行1次
auto timer_id = ctx->AddPeriodicCallback(std::chrono::microseconds{500}, [this](auto id) {
  // do sth.
  // 不需要了的话既可以在外面取消，也可以在内部取消
  // ctx->RemoveTimer(id);
});
// 如果不需要了，可以移除定时器
ctx->RemoveTimer(timer_id);
// 可以支持多种时间类型
ctx->AddPeriodicCallback(std::chrono::milliseconds{1}, [this](auto) {});
ctx->AddPeriodicCallback(std::chrono::seconds{1}, [this](auto) {});

SubscribeMarketData

SubscribeMarketData用于订阅行情，一般在策略构造函数中调用，策略初始化时就应该知道该订阅哪些合约，不建议在策略运行过程中调用，否则会导致策略回测时无法加载行情数据

MyStrategy::MyStrategy(StrategyContext* ctx) {
  ctx->SubscribeMarketData({"FUT_SHFE_rb-202405", "FUT_SHFE_rb-202410"});  // 支持指定具体合约
  ctx->SubscribeMarketData({"FUT_SHFE_rb.+?"});  // 支持使用正则表达式，匹配规则与std::regex相同
  ctx->SubscribeMarketData({"FUT_SHFE_rb.+?", "FUT_SHFE_hc-202405"});  // 可以混合使用
}

UnsubscribeMarketData

取消订阅行情

MyStrategy::MyStrategy(StrategyContext* ctx) {
  ctx->UnsubscribeMarketData({"FUT_SHFE_rb-202405", "FUT_SHFE_rb-202410"});  // 支持指定具体合约
  ctx->UnsubscribeMarketData({"FUT_SHFE_rb.+?"});  // 支持使用正则表达式，匹配规则与std::regex相同
  ctx->UnsubscribeMarketData({"FUT_SHFE_rb.+?", "FUT_SHFE_hc-202405"});  // 可以混合使用
}

SubscribePosition

订阅物理持仓，只有订阅了物理持仓信息才能通过GetPosition读取到正确的物理持仓。逻辑持仓不受此影响，不管订阅与否策略都能读取到正确的逻辑持仓

ctx->SubscribePosition({"FUT_SHFE_rb-202405"});

UnsubscribePosition

策略可以取消订阅物理持仓

ctx->UnsubscribePosition({"FUT_SHFE_rb-202405"});

SubscribeTopics

XYTS提供了基于共享内存的低延迟消息队列，策略可以订阅感兴趣的topic，之后如有新消息会通过OnMessage进行推送

ctx->SubscribeTopics({1, 3, 5});

UnsubscribeTopics

策略可以取消订阅topic

ctx->UnsubscribeTopics({1, 3, 5});

GetWallTime

获取当前微秒精度的时间戳，实盘时返回的是当前时间，回测返回的回测时模拟的时间。尽可能使用该接口来获取时间，以确保实盘和回测行为能保持一致。另外，GetWallTime可配合xyu/datetime.h使用以获取更多功能

#include "xyu/datetime.h"

namespace dt = xyu::datetime;

// ...

auto ts = ctx->GetWallTime();
auto now = dt::datetime::fromtimestamp(ts);
LOG_INFO("{}", now.strftime("%Y-%m-%d %H:%M:%S.%f"));

SendAlarm

向外推送告警信息，可支持推送至企业微信

ctx->SendAlarm("Hello");

Stop

停止策略并退出程序，用于遇到BUG或是其他紧急情况下策略内部主动退出

ctx->Stop();

SendOrder

支持订单超时参数，超时会自动撤销订单

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
  // 设置了100ms的超时
  // 返回的client_order_id可对订单进行操作，如撤单、修改订单超时等，也可以用于在回报中识别订单
auto cli_order_id =
    ctx->SendOrder(contract->contract_id, 1, Direction::kBuy, PositionEffect::kAuto,
                   OrderType::kLimit, 3900, std::chrono::milliseconds{100});

Buy

对SendOrder的简单封装，PositionEffect为PositionEffect::kAuto

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
ctx->Buy(contract->contract_id, 1, OrderType::kLimit, 3900);

Sell

对SendOrder的简单封装，PositionEffect为PositionEffect::kAuto

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
ctx->Sell(contract->contract_id, 1, OrderType::kLimit, 3900);

CancelOrder

撤单，调用一次即可保证订单立刻结束

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
auto cli_order_id =
    ctx->SendOrder(contract->contract_id, 1, Direction::kBuy, PositionEffect::kAuto,
                   OrderType::kLimit, 3900, std::chrono::milliseconds{100});
ctx->CancelOrder(cli_order_id);

ResetOrderTimeout

重置订单超时时间

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
auto cli_order_id =
    ctx->SendOrder(contract->contract_id, 1, Direction::kBuy, PositionEffect::kAuto,
                   OrderType::kLimit, 3900, std::chrono::milliseconds{100});
// 重新设置成1s，超时是从设置的那一刻开始计算
ctx->ResetOrderTimeout(cli_order_id, std::chrono::seconds{1});

GetPosition

获取单个合约的实时物理持仓，效率很高

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
auto pos = ctx->GetPosition(contract->contract_id);

GetPositions

查询所有物理持仓，因为涉及到拷贝，如果合约量较大性能会稍差

auto positions = ctx->GetPositions();
for (const auto& position : positions) {
  // ...
}

GetLogicalPosition

获取单个合约的实时逻辑持仓，效率很高

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
auto pos = ctx->GetLogicalPosition(contract->contract_id);

GetLogicalPositions

查询所有逻辑持仓，因为涉及到拷贝，如果合约量较大性能会稍差

auto positions = ctx->GetLogicalPositions();
for (const auto& position : positions) {
  // ...
}

GetTrades

从数据库读取策略当日成交，性能较差，只适合在策略初始化时查询。如果要维护实时的成交列表，需要配合OnOrder回调使用

auto trades = ctx->GetTrades();  // 获取策略所有成交

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
auto rb2405_trades = ctx->GetTrades(contract->contract_id);  // 获取策略在rb2405上的成交

GetOrders

从数据库读取策略当日订单信息，性能较差，只适合在策略初始化时查询。如果要维护实时的订单列表，需要配合OnOrder回调使用

auto orders = ctx->GetOrders();  // 获取策略所有成交

auto contract = ContractTable::GetByInstrument("FUT_SHFE_rb-202405");
auto rb2405_orders = ctx->GetOrders(contract->contract_id);  // 获取策略在rb2405上的委托

GetAccount

查询帐户资金信息，这个一般用得比较少，需要填入配置的帐户名称

auto account = GetAccount("my_ctp_account");

GetPnl

查询策略从上线到目前为止的最新的累积pnl，如果有持仓需要订阅对应合约的行情才能获取到正确的值，如果GetPnl返回nan，说明还没有足够的行情用于计算pnl，需要继续收取行情

double pnl = GetPnl();

PublishMessage

策略可以通过PublishMessage往消息队列推送消息

data的最大长度有限制，定义在xyts/core/market_data.h的kMaxTopicMessageLen，超出的话接口会抛异常

Topic topic = 1;
const char* data = "hello, world";
ctx->PublishMessage(topic, data, strlen(data) + 1);

GetStrategyName

获取当前策略实例的名称

LOG_INFO("{}", ctx->GetStrategyName());

GetParamManager

获取策略参数对象，通常需要用dynamic_cast转换成相应的派生类型，参考典型策略程序示例这一章节的示例

GetDerivedParamManager

用dynamic_static对GetParamManager进行的简单封装

高级订单管理功能

高级订单管理功能提供了如套利、追踪止损、条件单等功能

OrderManager

OrderManager能同时在两个价位上分别挂上买单和卖单

#include "xyts/strategy/order_manager.h"
// include other necessary header files

class MyStrategy final : public Strategy {
 public:
  explicit MyStrategy(StrategyContext* ctx)
      : ctx_(ctx),
        param_(ctx->GetDerivedParamManager<MyStrategyParamManager>()),
        order_manager(ctx_) {
    ctx_->SubscribeMarketData({param_->get_instr()});
  }

  void OnDepth(const DepthData& depth) final {
    // 每次行情更新都会先撤销掉原来的订单，并在买1和卖1分别挂一手订单
    order_manager_.PlaceOrder(depth.contract_id, 1, depth.bid[0], 1, depth.ask[0]);
  }

  void OnOrder(const OrderResponse& rsp) final {
    order_manager_.OnOrder(rsp);
  }

 private:
  StrategyContext ctx_;
  MyStrategyParamManager* param_;
  OrderManager order_manager_;
};

ArbitrageManager

TargetPositionManager

策略通过TargetPositionManager设置目标持仓量后，TargetPositionManager会自动将持仓调整到目标持仓量，策略无需再处理订单逻辑。

#include "xyts/strategy/target_position_manager.h"
// include other necessary header files

class MyStrategy final : public Strategy {
 public:
  explicit MyStrategy(StrategyContext* ctx)
      : ctx_(ctx),
        param_(ctx->GetDerivedParamManager<MyStrategyParamManager>()),
        contract_(ContractTable::GetByInstrument(param_->get_instr())),
        target_pos_manager_(ctx_) {
    ctx_->SubscribeMarketData({param_->get_instr()});
  }

  void OnDepth(const DepthData& depth) final {
    if (depth.last_price > 3900) {
      target_pos_maager_.SetTargetPosition(depth.contract_id, -10);
    } else if (depth.last_price < 3880) {
      target_pos_maager_.SetTargetPosition(depth.contract_id, 10);
    }
    target_pos_manager_.OnDepth(depth);
  }

  void OnOrder(const OrderResponse& order) final { target_pos_manager_.OnOrder(rsp); }

 private:
  StrategyContext* ctx_;
  MyStrategyParamManager* param_;
  ContractPtr contract_;
  TargetPositionManager target_pos_manager_;
};

ConditionOrderManager

ConditionOrderManager用于支持条件单，条件单会在价格突破时触发

#include "xyts/strategy/condition_order_manager.h"
// include other necessary header files

class MyStrategy final : public Strategy {
 public:
  explicit MyStrategy(StrategyContext* ctx)
      : ctx_(ctx),
        param_(ctx->GetDerivedParamManager<MyStrategyParamManager>()),
        contract_(ContractTable::GetByInstrument(param_->get_instr())),
        cond_ord_manager_(ctx_) {
    ctx_->SubscribeMarketData({param_->get_instr()});

    const auto* contract = ContractTable::GetByInstrument(param_->get_instr());
    assert(contract);
    // 价格突破3950时买入5手
    ConditionOrder order{contract->contract_id, Direction::kBuy, PositionEffect::kAuto, 5, 3950};
    cond_ord_manager_.AddConditionOrder(order);
  }
  void OnDepth(const DepthData& depth) final { cond_ord_manager_.OnDepth(depth); }

  void OnOrder(const OrderResponse& order) final { cond_ord_manager_.OnOrder(order); }

 private:
  StrategyContext* ctx_;
  MyStrategyParamManager* param_;
  ContractPtr contract_;
  ConditionOrderManager cond_ord_manager_;
};

TrailingStopManager

TrailingStopManager用于追踪止损

#include "xyts/strategy/trailing_stop_manager.h"
// include other necessary header files

class MyStrategy final : public Strategy {
 public:
  explicit MyStrategy(StrategyContext* ctx)
      : ctx_(ctx),
        param_(ctx->GetDerivedParamManager<MyStrategyParamManager>()),
        contract_(ContractTable::GetByInstrument(param_->get_instr())),
        trailing_stop_manager_(ctx_) {
    ctx_->SubscribeMarketData({param_->get_instr()});

    const auto* contract = ContractTable::GetByInstrument(param_->get_instr());
    assert(contract);
    // 持仓方向为多头，基准价格为3900，初始的止损价格为3880，当价格进一步上涨时，止损价格会被抬高，
    // 当最新价跌破追踪止损价格时，卖出2手来止损
    trailing_stop_manager_.AddTrailingStop(contract->contract_id, Direction::kBuy, 2, 3900, 20);
  }

  void OnDepth(const DepthData& depth) final { trailing_stop_manager_.OnDepth(depth); }

  void OnOrder(const OrderResponse& order) final { trailing_stop_manager_.OnOrder(order); }

 private:
  StrategyContext* ctx_;
  MyStrategyParamManager* param_;
  ContractPtr contract_;
  TrailingStopManager trailing_stop_manager_;
};

GridTradingBot

网格交易，支持固定网格大小、固定的price_tick以及固定的价格比例

#include "xyts/strategy/grid_trading_bot.h"
// include other necessary header files

class MyStrategy final : public Strategy {
 public:
  explicit MyStrategy(StrategyContext* ctx)
      : ctx_(ctx),
        param_(ctx->GetDerivedParamManager<MyStrategyParamManager>()),
        contract_(ContractTable::GetByInstrument(param_->get_instr())) {
    ctx_->SubscribeMarketData({param_->get_instr()});
    if (std::filesystem::exists(grid_trading_dump_)) {
      grid_trading_bot_ = GridTradingBot::Load(ctx, grid_trading_dump_);
    } else {
      grid_trading_bot_ = std::make_unique<GridTradingBot>(
          ctx, contract, 1, GridHeight(0.01, GridHeightType::kRatioLength));
    }
  }

  ~MyStrategy() {
    grid_trading_bot_->Dump(grid_trading_dump_);
  }

  void OnDepth(const DepthData& depth) final { grid_trading_bot_->OnDepth(depth); }

  void OnOrder(const OrderResponse& order) final { grid_trading_bot_->OnOrder(order); }

 private:
  StrategyContext* ctx_;
  MyStrategyParamManager* param_;
  ContractPtr contract_;
  std::unique_ptr<GridTradingBot> grid_trading_bot_;
  std::string grid_trading_dump_ = "../data/my_grid_trading_bot.json";
};

AutoSpreader

SpreadGridTradingBot

算法交易

使用方式

#include "xyts/strategy/algo_trading_service.h"
// #include others

class MyStrategy final : public Strategy {
 public:
  explicit MyStrategy(StrategyContext* ctx)
      : ctx_(ctx),
        param_(ctx->GetDerivedParamManager<MyStrategyParamManager>()),
        contract_(ContractTable::GetByInstrument(param_->get_instr())),
        algo_trading_service_(ctx_) {
    ctx_->SubscribeMarketData({param_->get_instr()});
    ctx_->SubscribePosition({param_->get_instr()});
  }

  void OnDepth(const DepthData& depth) final {
    algo_trading_service_.OnDepth(depth);
    if (satisfied condition) {
      nlohmann::json algo_params{{"algo_name", "Iceberg"},
                                 {"instr", contract_->instr},
                                 {"direction", "Buy"},
                                 {"position_effect", "Auto"},
                                 {"volume", 100},
                                 {"timeout", 10 * 1000000},
                                 {"price_depth", 0.5},
                                 {"interval", 2 * 1000000},
                                 {"start_time", 0},
                                 {"order_type", "price_preferred"},
                                 {"display_vol", 0.2},
                                 {"price_tick_added", 0},
                                 {"reject_interval", 3 * 1000000},
                                 {"imb_sum_ratio", 0.5},
                                 {"imb_level1_ratio", 0.5},
                                 {"traded_interval", 1 * 1000000},
                                 {"allow_pending_up_limit", false},
                                 {"allow_pending_down_limit", true}};
      algo_trading_service_.AddAlgoOrder(algo_params);
    }
  }

  void OnOrder(const OrderResponse& order) final { algo_trading_service_.OnOrder(order); }

 private:
  StrategyContext* ctx_;
  MyStrategyParamManager* param_;
  ContractPtr contract_;
  AlgoTradingService algo_trading_service_;
};

支持的算法类型：

所有参数中的时间单位均是微秒

每个算法都共有的参数

{
  "algo_name": "TWAP/VWAP/...",
  "instr": "000001.XSHE",
  "direction": "Buy",
  "position_effect": "Auto",
  "volume": 10000,
  "timeout": "30000000"
}

TWAP

简介：根据时间加权平均市价，间隔时间发单

参数说明:

start_time, end_time：控制TWAP开始与结束的时间（算法可能会因成交慢完成时间滞后于给定时间）
reject_interval:订单被拒后，间隔多久重发
duration: 每隔多少微秒发送子单
price_tick_added: 超时后，调整子单的价格。为当前时间twap +- price_tick_added * unit_price_tick

示例

{
  "algo_name": "TWAP",
  "start_time": 1705064340608000,
  "end_time": 1705064400888000,
  "duration": 30000000,
  "reject_interval": 500000,
  "price_tick_added": 1
}

VWAP

简介：根据成交量加权平均市价，间隔时间发单

具体参数解释：和TWAP参数一致，除了duration需要最小间隔分钟，如 algo_params["duration"] = 60000000

示例

{
  "algo_name": "VWAP",
  "start_time": 1705064340608000,
  "end_time": 1705064400888000,
  "duration": 60000000,
  "reject_interval": 500000,
  "price_tick_added": 1
}

IS

简介：将冲击成本与时间成本考虑在内，给定风险系数下，求最优分单

具体参数解释:

risk_aversion：风险厌恶系数(>0)，越大表示对时间冲击成本带来风险越谨慎，故会尽可能提早完成算法单(开始时，子单大小很大)
total_time：表示执行的总时间，duration表示间隔时间，两者最小单位均需要是分钟。

示例

{
  "algo_name":"IS",
  "total_time": 60000000,
  "risk_aversion": 0.5,
  "duration": 10000000,
  "reject_interval": 500000,
  "price_tick_added": 1
}

Iceberg

简介：根据显示数量参数，在某个档位或以对价发送小额单，只有上一笔子单完成，才会继续发送下笔，直到成交量满足给定额

具体参数解释：

order_type: 发单类型，分为两种 1.时间优先"time_preferred" 2.价格优先"price_preferred"
display_vol: 每笔子单显示数量，如果是分数(0-1)，则按当前市场五档挂单数量均值*给定分数动态计子单数量大小;如果是整数，则按给定整数定值确定每笔子单数额
interval: 每隔多少微秒检测子单价格是否波动太大
reject_interval: 订单被拒后,间隔多久重发
traded_interval: 订单完全成交后,间隔多久发下笔子单
imb_sum_ratio: 判断买卖势力加上一个比率,在买单中,如果sum_asks/sum_bids > ratio,才有可能bid1单; 如果想要更快成交(打对价)，将该ratio调为>1的值即可，反之<1
imb_level1_ratio: 同上,但是检测的是ask1/bid1
allow_pending_up_limit: 涨停板下，允许一直挂单(没有超时)
allow_pending_down_limit: 跌停板下，允许一直挂单(没有超时)
last_order_kbest: 科创板下，零股是否发市价单
price_depth: 检查价格深度(百分比),如果子单价格超过当前价格的2 * price_depth/100，则撤销发。（其中小市值股票根据price_tick判断）
price_tick_added: 只在价格优先下有用,会根据price_tick_added，调整价格发出

示例

{
  "algo_name":"Iceberg",
  "price_depth": 0.2,
  "interval": 2000000,
  "start_time": 1705064340608000,
  "display_vol": 0.2,
  "reject_interval": 500000,
  "traded_interval": 500000,
  "imb_sum_ratio": 0,
  "imb_level1_ratio": 0,
  "price_tick_added": 0,
  "allow_pending_up_limit": true,
  "allow_pending_down_limit": true
}

Sniper

简介：市场行情达到给定条件，则立刻发对价单，数额是对价一档挂单量，直到完成给定数额

具体参数解释：

aggressiveness: 是时间间隔，再发送上一笔子单后，超过aggressiveness微秒后，才能发送下一笔达到条件的子单

示例

{
  "algo_name":"Sniper",
  "start_time": 1705064340608000,
  "aggressiveness": 100000
}

BarGenerator: 实时K线合成

BarGenerator支持实时合成多种周期的K线，如3s/5s/6s/10s/15s/20s/30s/1min/3min/5min/15min等

class MyStrategy final : public Strategy {
 public:
  explicit MyStrategy(StrategyContext* ctx)
      : ctx_(ctx),
        param_(ctx->GetDerivedParamManager<MyStrategyParamManager>()),
        bargen_(ctx) {
    // 1min
    bargen_.AddBarPeriod({"FUT_SHFE_rb-.+?"}, std::chrono::seconds{60},
                         [this](const BarData& bar) { OnBar1Min(bar); });
    // 5min
    bargen_.AddBarPeriod({"FUT_SHFE_rb-.+?"}, std::chrono::seconds{300},
                         [this](const BarData& bar) { OnBar5Min(bar); });
  }

  void OnDepth(const DepthData& depth) final { bargen_.UpdateBar(depth); }

  void OnBar1Min(const BarData& bar) {}

  void OnBar5Min(const BarData& bar) {}

 private:
  StrategyContext* ctx_;
  MyStrategyParamManager* param_;
  BarGenerator bargen_;
};

下面是BarGenerator的实现，供参考学习

// bar_generator.h
#pragma once

#include <functional>
#include <memory>
#include <vector>

#include "xyts/core/contract_table.h"
#include "xyts/core/market_data.h"
#include "xyts/strategy/strategy_context.h"

namespace xyts::strategy {

using BarCallback = std::function<void(const BarData&)>;

class BarGenerator {
 public:
  explicit BarGenerator(StrategyContext* ctx);

  ~BarGenerator();

  void AddBarPeriod(const std::vector<std::string>& patterns, std::chrono::seconds period,
                    BarCallback&& cb);

  void UpdateBar(const DepthData& depth);

 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};

}  // namespace xyts::strategy

// bar_generator.cpp
#include "xyts/strategy/bar_generator.h"

#include <optional>
#include <string>

#include "xydata/bar.h"
#include "xyu/datetime.h"

namespace dt = xyu::datetime;

namespace xyts::strategy {

class BarGenHelper {
 public:
  BarGenHelper(StrategyContext* ctx, ContractPtr contract, std::chrono::seconds period,
               BarCallback cb);

  ~BarGenHelper();

  void UpdateBar(const DepthData& depth);

  void CheckBar(std::chrono::microseconds now_ts);

  ContractPtr contract() const { return contract_; }

  Volume last_volume() const { return last_depth_ ? last_depth_->volume : 0; }

  double last_turnover() const { return last_depth_ ? last_depth_->turnover : 0; }

  std::chrono::seconds period() const { return bar_.period; }

 private:
  void OpenBar(const DepthData& depth);

  void CloseBar(std::chrono::microseconds bar_time);

  StrategyContext* ctx_;
  ContractPtr contract_;
  BarCallback cb_;

  std::vector<std::vector<std::chrono::microseconds>> intervals_;
  std::size_t interval_idx_ = 0;

  std::optional<DepthData> last_depth_;
  BarData bar_{};
  double open_px_ = std::numeric_limits<double>::quiet_NaN();
  double high_px_ = std::numeric_limits<double>::quiet_NaN();
  double low_px_ = std::numeric_limits<double>::quiet_NaN();
};

BarGenHelper::BarGenHelper(StrategyContext* ctx, ContractPtr contract, std::chrono::seconds period,
                           BarCallback cb)
    : ctx_(ctx), contract_(contract), cb_(cb) {
  bar_.contract_id = contract_->contract_id;
  snprintf(bar_.source, sizeof(bar_.source), "bargen");
  bar_.period = period;

  auto now_ts = ctx->GetWallTime();
  auto now = dt::datetime::fromtimestamp(now_ts);
  auto today = now.date();

  const auto* all_sessions = contract_->sessions;
  if (!all_sessions) {
    throw std::runtime_error("Failed to get sessions of " + contract_->instr);
  }
  std::vector<xydata::Session> sessions;
  for (const auto& session : all_sessions->GetAllTradingSessions()) {
    if (now.hour() >= 8 && now.hour() <= 16) {
      if (session.open.hour() >= 8 && session.open.hour() <= 16) {
        sessions.emplace_back(session);
      }
    } else {
      if (session.open.hour() >= 20 || session.open.hour() <= 3) {
        sessions.emplace_back(session);
      }
    }
  }

  auto time_intervals = xydata::SplitToBarIntervals(sessions, period);
  auto combine_trading_date = [&](const auto& t) {
    if (t >= dt::time(0) && t <= dt::time(3)) {
      return dt::datetime::combine(today + dt::timedelta(1), t).timestamp();
    } else {
      return dt::datetime::combine(today, t).timestamp();
    }
  };
  for (const auto& time_itv : time_intervals) {
    std::vector<std::chrono::microseconds> interval;
    interval.emplace_back(combine_trading_date(time_itv.begin));
    interval.emplace_back(combine_trading_date(time_itv.end));
    interval.emplace_back(combine_trading_date(time_itv.bar_time));
    intervals_.emplace_back(std::move(interval));
  }
  while (interval_idx_ < intervals_.size()) {
    if (now_ts < intervals_[interval_idx_][1] + std::chrono::seconds{1}) {
      break;
    }
    interval_idx_++;
  }
}

BarGenHelper::~BarGenHelper() {}

void BarGenHelper::UpdateBar(const DepthData& depth) {
  if (interval_idx_ >= intervals_.size()) {
    return;
  }
  if (depth.volume == 0) {
    return;
  }

  const auto& interval = intervals_[interval_idx_];
  if (depth.exchange_timestamp < interval[0]) {
    return;
  }
  if (depth.exchange_timestamp > interval[1]) {
    interval_idx_++;
    if (!last_depth_) {
      OpenBar(depth);
    } else {
      CloseBar(interval[2]);
      OpenBar(depth);
    }
  } else {
    if (!last_depth_ || std::isnan(open_px_)) {
      OpenBar(depth);
    } else {
      high_px_ = std::max(high_px_, depth.last_price);
      low_px_ = std::min(low_px_, depth.last_price);
    }
  }
  last_depth_ = depth;
}

void BarGenHelper::OpenBar(const DepthData& depth) {
  open_px_ = depth.last_price;
  high_px_ = depth.last_price;
  low_px_ = depth.last_price;
}

void BarGenHelper::CloseBar(std::chrono::microseconds bar_time) {
  if (std::isnan(open_px_)) {
    OpenBar(*last_depth_);
  }
  bar_.exchange_timestamp = bar_time;
  bar_.local_timestamp = ctx_->GetWallTime();
  bar_.volume = last_depth_->volume;
  bar_.turnover = last_depth_->turnover;
  bar_.open_price = open_px_;
  bar_.high_price = high_px_;
  bar_.low_price = low_px_;
  bar_.close_price = last_depth_->last_price;
  cb_(bar_);
}

void BarGenHelper::CheckBar(std::chrono::microseconds now_ts) {
  if (interval_idx_ >= intervals_.size()) {
    return;
  }
  const auto& interval = intervals_[interval_idx_];
  if (now_ts >= interval[1] + std::chrono::seconds{1}) {
    interval_idx_++;
    if (last_depth_) {
      CloseBar(interval[2]);
      open_px_ = std::numeric_limits<double>::quiet_NaN();
      high_px_ = std::numeric_limits<double>::quiet_NaN();
      low_px_ = std::numeric_limits<double>::quiet_NaN();
    }
  }
}

class BarGenerator::Impl {
 public:
  explicit Impl(StrategyContext* ctx);

  ~Impl();

  void AddBarPeriod(const std::vector<std::string>& patterns, std::chrono::seconds period,
                    BarCallback&& cb);

  void UpdateBar(const DepthData& depth);

 private:
  void CheckBars();

  StrategyContext* ctx_;
  std::unordered_map<ContractId, std::vector<std::shared_ptr<BarGenHelper>>> contract_to_helpers_;
  std::vector<std::shared_ptr<BarGenHelper>> all_helpers_;

  EventId timer_id_ = -1;
};

BarGenerator::Impl::Impl(StrategyContext* ctx) : ctx_(ctx) {
  timer_id_ = ctx_->AddPeriodicCallback(std::chrono::seconds{1}, [this](auto) { CheckBars(); });
}

void BarGenerator::Impl::AddBarPeriod(const std::vector<std::string>& patterns,
                                      std::chrono::seconds period, BarCallback&& cb) {
  auto contracts = ContractTable::GetByPatterns(patterns);
  for (const auto* contract : contracts) {
    auto& helpers = contract_to_helpers_[contract->contract_id];
    auto it = std::find_if(helpers.begin(), helpers.end(),
                           [period](const auto& helper) { return helper->period() == period; });
    if (it != helpers.end()) {
      continue;
    }
    auto helper = std::make_shared<BarGenHelper>(ctx_, contract, period, cb);
    helpers.emplace_back(helper);
    all_helpers_.emplace_back(helper);
  }
}

BarGenerator::Impl::~Impl() { ctx_->RemoveTimer(timer_id_); }

void BarGenerator::Impl::UpdateBar(const DepthData& depth) {
  if (auto it = contract_to_helpers_.find(depth.contract_id); it != contract_to_helpers_.end()) {
    for (const auto& helper : it->second) {
      helper->UpdateBar(depth);
    }
  }
}

void BarGenerator::Impl::CheckBars() {
  auto now_ts = ctx_->GetWallTime();
  for (const auto& helper : all_helpers_) {
    helper->CheckBar(now_ts);
  }
}

BarGenerator::BarGenerator(StrategyContext* ctx) : impl_(std::make_unique<Impl>(ctx)) {}

BarGenerator::~BarGenerator() {}

void BarGenerator::AddBarPeriod(const std::vector<std::string>& patterns,
                                std::chrono::seconds period, BarCallback&& cb) {
  impl_->AddBarPeriod(patterns, period, std::move(cb));
}

void BarGenerator::UpdateBar(const DepthData& depth) { impl_->UpdateBar(depth); }

}  // namespace xyts::strategy

实盘MarketDataFilter扩展

实盘中，如果同时接入了多个相同的行情源，用户可加载自定义的行情过滤器，xyts默认提供了两个过滤器

duplicate_filter: 行情择优去重
timeout_filter: 如果行情的交易所时间戳比本地接收时间戳小得多，则丢弃该行情

在market_center.yaml中配置filter即可使用

market_data_filters:
  - name: duplicate_filter
    errata_ms: 50
  - name: timeout_filter
    timeout_ms: 5000

MarketDataFilter支持扩展，用户可将自定义的MarketFilter编译成so放在lib下即可加载

#pragma once

#include <chrono>

#include "xyts/market_data_filter/market_data_filter.h"

namespace xyts {

class MyFilter final : public MarketDataFilter {
 public:
  explicit MyFilter(const YAML::Node& conf)
      : timeout_(std::chrono::milliseconds(conf["timeout_ms"].as<int64_t>())) {}

  bool Accept(const DepthData& depth) final {
    return depth.local_timestamp - depth.exchange_timestamp < timeout;
  }

 private:
  std::chrono::milliseconds timeout_;
};

REGISTER_MARKET_DATA_FILTER("my_filter", MyFilter);

}  // namespace xyts

add_library(my_filter SHARED)
target_include_directories(
my_filter
  PRIVATE
    "${CMAKE_SOURCE_DIR}/include"
    "${CMAKE_SOURCE_DIR}/third_party/yaml-cpp/include")

# market_center.yaml
market_data_filters:
  - name: timeout_filter
    timeout_ms: 1000

实盘DataCollector扩展

交易过程中，交易信息（如订单、成交、持仓、账户资金、告警等）会通过发送到DataCollector模块用于实时监控，xyts默认提供了企业微信告警通知模块，用户也可自定义DataHandler来跟第三方或自己开发的监控进行对接。下面是个扩展的例子

#pragma once

#include <openssl/tls1.h>

#include <boost/asio.hpp>
#include <boost/asio/ssl/context.hpp>
#include <boost/beast.hpp>
#include <boost/beast/websocket/ssl.hpp>
#include <boost/system/error_code.hpp>

#include "xyts/data_collector/collected_data_handler.h"
#include "yaml-cpp/yaml.h"

namespace xyts {

class WechatSender final : public CollectedDataHandler {
 public:
  explicit WechatSender(const YAML::Node& conf);

  void Handle(CollectedDataType type, const std::string& data) final;

 private:
  void SendAlarmMsg(const std::string& data);

  boost::asio::io_context ioc_;
  boost::asio::ssl::context ssl_{boost::asio::ssl::context::tlsv12_client};
  std::string wechat_host_ = "qyapi.weixin.qq.com";
  std::string wechat_robot_key_;
  std::string target_;
};

}  // namespace xyts

实盘TradeApi扩展

xyts目前对接了以下api:

ctp
ctp2mini
binance
yd
xele
xtp

如需对接其他交易API，可继承TradeApi并实现相应的虚函数

class TradeApi {
 public:
  virtual ~TradeApi() = default;

  virtual bool SendOrder(const OrderRequest& request) = 0;

  virtual bool CancelOrder(const CancellationRequest& request) = 0;

  virtual TradeInfo QueryTradeInfo() = 0;

  virtual std::vector<Contract> QueryContracts() = 0;

  virtual std::vector<Account> QueryAccounts() = 0;

  auto* GetEventRing() { return &event_ring_; }

 protected:
  template <class EventType>
  void PushEvent(const EventType& event) {
    auto* ptr = event_ring_.PrepareEnqueueBlocking();
    *ptr = event;
    event_ring_.CommitEnqueue();
  }

 private:
  using OrderEventRing = xyu::SPSCRingBuffer<OrderEvent, 1024>;
  OrderEventRing event_ring_;
};

实盘DataFeedApi扩展

xyts目前对接了以下api:

ctp
ctp2mini
binance
yd
xtp

如需对接其他行情API，可继承DataFeedApi并实现相应的虚函数

class DataFeedApi : public xyu::NonCopyableNonMoveable {
 public:
  virtual ~DataFeedApi() = default;

  virtual DataFeedStatus GetStatus() const = 0;

  virtual bool Subscribe(const std::vector<std::string>& patterns) = 0;

  virtual bool Unsubscribe(const std::vector<std::string>& patterns) = 0;
};

OrderBook

实时合成OrderBook，且能够以自定义频率进行快照采样，目前支持的交易所有：上交所、深交所、港交所

回测里的MatchingEngine扩展

回测里的自定义费率

合约标准命名规则

中国期货

FUT_{exchange}_{symbol}-{YYYYmm}

其中exchange和symbol对应交易所的命名，如

FUT_SHFE_rb-202405
FUT_CZCE_WH-202405

包括郑商所在内的所有交易所都遵循上述6位到期日的命名规则

主力合约的YYYYmm规定为111111，如

FUT_SHFE_rb-111111
FUT_SHFE_hc-111111

期权

OPT_{exchange}_{symbol}-{YYYYmm}-{C/P}-{strike}

如

OPT_XSHG_510300-202409-C-3.25
OPT_CFFEX_IO-202409-P-3500

xydata

xydata提供历史行情数据和当日历史行情数据的访问接口

xydata数据的组织方式

data/
    depth/
        2024-01-15/
            FUT_SHFE_rb-202405.csv
    contract/
        comm_deri_contracts_2024-01-15.csv
    holiday/
        2024.csv

除了holiday中的内容需要自己手动填写，合约和行情数据都能从实盘中获取并存储下来，XYTS也支持每天落地数据并更新到xydata中

depth

快照按照日期及合约名来存储

以FUT_SHFE_rb-202405.csv前几行为例来说明数据格式

local_timestamp,exchange_timestamp,open_interest,volume,turnover,last_price,bid_volume_1,bid_price_1,ask_volume_3,ask_price_3,ask_volume_1,ask_price_1,bid_volume_4,bid_price_4,bid_volume_2,bid_price_2,ask_volume_4,ask_price_4,ask_volume_2,ask_price_2,bid_volume_5,bid_price_5,bid_volume_3,bid_price_3,ask_volume_5,ask_price_5,instrument
1705063808381581,1705055979200000,1518179,0,0,3902,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,FUT_SHFE_rb-202405
1705064340608710,1705064340500000,1520933,7550,294827500,3905,836,3905,230,3908,1036,3906,1185,3902,6,3904,283,3909,137,3907,43,3901,22,3903,477,3910,FUT_SHFE_rb-202405
1705064400607038,1705064400500000,1520956,8592,335515850,3904,13,3903,1029,3906,3,3904,1683,3900,1184,3902,160,3907,404,3905,216,3899,109,3901,280,3908,FUT_SHFE_rb-202405
1705064401083261,1705064401000000,1520861,9226,360268510,3905,10,3904,160,3907,366,3905,103,3901,124,3903,290,3908,1040,3906,1753,3900,1139,3902,305,3909,FUT_SHFE_rb-202405
1705064401638857,1705064401500000,1521087,9891,386227820,3904,231,3904,162,3907,349,3905,107,3901,5,3903,282,3908,1053,3906,1755,3900,1029,3902,437,3909,FUT_SHFE_rb-202405

数据字段，顺序无关紧要：

local_timestamp: 本地收到数据的微秒时间戳
exchange_timestamp: 交易所微秒时间戳
open_interest: 持仓量
volume: 成交量
turnover: 成交额
last_price: 最新成交价
bid_volume_1 ~ bid_volume_5: 买1到买5的量
bid_price_1 ~ bid_price_5: 买1到买5的价格
ask_volume_1 ~ ask_volume_5: 卖1到卖5的量
ask_price_1 ~ ask_price_5: 卖1到卖5的价格
instrument: 合约标准命名

contract

以comm_deri_contracts_2024-01-15.csv前几行为例来说明数据格式

contract_id,instr,code,exchange,product_type,contract_unit,price_tick,upper_limit_price,lower_limit_price,long_margin_rate,short_margin_rate,max_limit_order_volume,min_limit_order_volume,max_market_order_volume,min_market_order_volume,list_date,expire_date,underlying_type,underlying_symbol,exercise_date,exercise_price
1,FUT_SHFE_pb-202412,pb2412,SHFE,Futures,5,5,17290,15335,0.08,0.08,500,1,30,1,,2024-12-16,Unknown,,,0
2,FUT_SHFE_rb-202401,rb2401,SHFE,Futures,10,1,4123,3730,0.2,0.2,500,30,30,30,,2024-01-15,Unknown,,,0
3,FUT_SHFE_rb-202402,rb2402,SHFE,Futures,10,1,4008,3627,0.1,0.1,500,1,30,1,,2024-02-19,Unknown,,,0
4,FUT_SHFE_rb-202403,rb2403,SHFE,Futures,10,1,4066,3679,0.07,0.07,500,1,30,1,,2024-03-15,Unknown,,,0
5,FUT_SHFE_rb-202404,rb2404,SHFE,Futures,10,1,4085,3696,0.07,0.07,500,1,30,1,,2024-04-15,Unknown,,,0
6,FUT_SHFE_rb-202405,rb2405,SHFE,Futures,10,1,4110,3719,0.07,0.07,500,1,30,1,,2024-05-15,Unknown,,,0