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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use crate::{prelude::Side, types::Order};

/// Common transaction fees
/// Fee calculation is determined by the fee model.
#[derive(Clone)]
pub struct CommonFees {
    /// Fee for adding liquidity (maker order).
    maker_fee: f64,
    /// Fee for removing liquidity (taker order).
    taker_fee: f64,
}

impl CommonFees {
    /// Constructs `CommonFees`.
    pub fn new(maker_fee: f64, taker_fee: f64) -> Self {
        Self {
            maker_fee,
            taker_fee,
        }
    }
}

/// Directional fees, such as stamp duty, are typically charged based on the transaction value in
/// addition to the common transaction fees.
#[derive(Clone)]
pub struct DirectionalFees {
    /// The common transaction fees
    common_fees: CommonFees,
    /// Buyer fee based on the transaction value
    buyer_fee: f64,
    /// Seller fee based on the transaction value
    seller_fee: f64,
}

impl DirectionalFees {
    /// Constructs `DirectionalFees`.
    pub fn new(common_fees: CommonFees, buyer_fee: f64, seller_fee: f64) -> Self {
        Self {
            common_fees,
            buyer_fee,
            seller_fee,
        }
    }
}

/// Provides the fee.
pub trait FeeModel {
    /// Calculates the fee amount.
    fn amount(&self, order: &Order, amount: f64) -> f64;
}

/// Fee based on the transaction value,
/// with the rate depending on whether the order is a maker or taker.
#[derive(Clone)]
pub struct TradingValueFeeModel<Fees> {
    fees: Fees,
}

impl<Fees> TradingValueFeeModel<Fees> {
    /// Constructs `TradingValueFeeModel`.
    pub fn new(fees: Fees) -> Self {
        Self { fees }
    }
}

impl FeeModel for TradingValueFeeModel<CommonFees> {
    fn amount(&self, order: &Order, amount: f64) -> f64 {
        if order.maker {
            self.fees.maker_fee * amount
        } else {
            self.fees.taker_fee * amount
        }
    }
}

impl FeeModel for TradingValueFeeModel<DirectionalFees> {
    fn amount(&self, order: &Order, amount: f64) -> f64 {
        match (order.maker, order.side) {
            (true, Side::Buy) => (self.fees.common_fees.maker_fee + self.fees.buyer_fee) * amount,
            (false, Side::Buy) => (self.fees.common_fees.taker_fee + self.fees.buyer_fee) * amount,
            (true, Side::Sell) => (self.fees.common_fees.maker_fee + self.fees.seller_fee) * amount,
            (false, Side::Sell) => {
                (self.fees.common_fees.taker_fee + self.fees.seller_fee) * amount
            }
            _ => unreachable!(),
        }
    }
}

/// Fee based on the transaction quantity,
/// with the rate depending on whether the order is a maker or taker.
#[derive(Clone)]
pub struct TradingQtyFeeModel<Fees> {
    fees: Fees,
}

impl<Fees> TradingQtyFeeModel<Fees> {
    /// Constructs `TradingQtyFeeModel`.
    pub fn new(fees: Fees) -> Self {
        Self { fees }
    }
}
impl FeeModel for TradingQtyFeeModel<CommonFees> {
    fn amount(&self, order: &Order, _amount: f64) -> f64 {
        if order.maker {
            self.fees.maker_fee * order.exec_qty
        } else {
            self.fees.taker_fee * order.exec_qty
        }
    }
}

impl FeeModel for TradingQtyFeeModel<DirectionalFees> {
    fn amount(&self, order: &Order, amount: f64) -> f64 {
        match (order.maker, order.side) {
            (true, Side::Buy) => {
                self.fees.common_fees.maker_fee * order.exec_qty + self.fees.buyer_fee * amount
            }
            (false, Side::Buy) => {
                self.fees.common_fees.taker_fee * order.exec_qty + self.fees.buyer_fee * amount
            }
            (true, Side::Sell) => {
                self.fees.common_fees.maker_fee * order.exec_qty + self.fees.seller_fee * amount
            }
            (false, Side::Sell) => {
                self.fees.common_fees.taker_fee * order.exec_qty + self.fees.seller_fee * amount
            }
            _ => unreachable!(),
        }
    }
}

/// Flat fee per trade
#[derive(Clone)]
pub struct FlatPerTradeFeeModel<Fees> {
    fees: Fees,
}
impl<Fees> FlatPerTradeFeeModel<Fees> {
    /// Constructs `FlatPerTradeFeeModel`.
    pub fn new(fees: Fees) -> Self {
        Self { fees }
    }
}

impl FeeModel for FlatPerTradeFeeModel<CommonFees> {
    fn amount(&self, order: &Order, _amount: f64) -> f64 {
        if order.maker {
            self.fees.maker_fee
        } else {
            self.fees.taker_fee
        }
    }
}