hftbacktest 0.9.4

A high-frequency trading and market-making backtesting tool accounts for limit orders, queue positions, and latencies, utilizing full tick data for trades and order books.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use algo::gridtrading;
use chrono::Utc;
use hftbacktest::{
    live::{LiveBot, LoggingRecorder, ipc::iceoryx::IceoryxUnifiedChannel},
    prelude::{Bot, HashMapMarketDepth, Status},
};
use tracing::info;

mod algo;

const ORDER_PREFIX: &str = "prefix";

fn prepare_live() -> LiveBot<IceoryxUnifiedChannel, HashMapMarketDepth> {
    let mut hbt = LiveBot::builder()
        .register("binancefutures", "SOLUSDT", 0.001, 1.0)
        .order_recv_hook(|req, resp| {
            if (req.req == Status::New || req.req == Status::Canceled) && (resp.req == Status::None)
            {
                info!(
                    req_timestamp = req.local_timestamp,
                    exch_timestamp = resp.exch_timestamp,
                    resp_timestamp = Utc::now().timestamp_nanos_opt().unwrap(),
                    req = ?req.req,
                    "Order response is received."
                );
            }
            Ok(())
        })
        .build()
        .unwrap();

    hbt
}

fn main() {
    tracing_subscriber::fmt::init();

    let mut hbt = prepare_live();

    let relative_half_spread = 0.0005;
    let relative_grid_interval = 0.0005;
    let grid_num = 10;
    let min_grid_step = 0.001; // tick size
    let skew = relative_half_spread / grid_num as f64;
    let order_qty = 1.0;
    let max_position = grid_num as f64 * order_qty;

    let mut recorder = LoggingRecorder::new();
    gridtrading(
        &mut hbt,
        &mut recorder,
        relative_half_spread,
        relative_grid_interval,
        grid_num,
        min_grid_step,
        skew,
        order_qty,
        max_position,
    )
    .unwrap();
    hbt.close().unwrap();
}