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
63
64
65

use std::collections::{HashMap, hash_map::Entry};

use tracing::info;

use crate::{
    depth::MarketDepth,
    prelude::{Bot, get_precision},
    types::{Recorder, StateValues},
};

/// Provides logging of the live strategy's state values.
#[derive(Default)]
pub struct LoggingRecorder {
    state: HashMap<usize, (f64, StateValues)>,
}

impl Recorder for LoggingRecorder {
    type Error = ();

    fn record<MD, I>(&mut self, hbt: &I) -> Result<(), Self::Error>
    where
        MD: MarketDepth,
        I: Bot<MD>,
    {
        for asset_no in 0..hbt.num_assets() {
            let depth = hbt.depth(asset_no);
            let price_prec = get_precision(depth.tick_size());
            let mid = (depth.best_bid() + depth.best_ask()) / 2.0;
            let state_values = hbt.state_values(asset_no);
            let updated = match self.state.entry(asset_no) {
                Entry::Occupied(mut entry) => {
                    let (prev_mid, prev_state_values) = entry.get();
                    if (*prev_mid != mid) || (prev_state_values != state_values) {
                        *entry.get_mut() = (mid, state_values.clone());
                        true
                    } else {
                        false
                    }
                }
                Entry::Vacant(entry) => {
                    entry.insert((mid, state_values.clone()));
                    true
                }
            };
            if updated {
                info!(
                    %asset_no,
                    %mid,
                    bid = format!("{:.prec$}", depth.best_bid(), prec = price_prec),
                    ask = format!("{:.prec$}", depth.best_ask(), prec = price_prec),
                    ?state_values,
                    "The state of asset number {asset_no} has been updated."
                );
            }
        }
        Ok(())
    }
}

impl LoggingRecorder {
    /// Constructs an instance of `LoggingRecorder`.
    pub fn new() -> Self {
        Default::default()
    }
}