nanobook 0.9.2

Production-grade Rust execution infrastructure for automated trading: LOB engine, portfolio simulator, broker abstraction, risk engine
Documentation 
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
154
155

//! Multi-symbol exchange: one LOB per symbol.

use crate::{Exchange, Price, Symbol};
use rustc_hash::FxHashMap;

/// A collection of per-symbol `Exchange` instances.
///
/// Each symbol gets its own independent order book. This is the entry point
/// for multi-asset simulations.
///
/// ```
/// use nanobook::{MultiExchange, Symbol, Side, Price, TimeInForce};
///
/// let mut multi = MultiExchange::new();
///
/// let aapl = Symbol::new("AAPL");
/// let msft = Symbol::new("MSFT");
///
/// // Orders are routed to per-symbol books
/// multi.get_or_create(&aapl).submit_limit(Side::Sell, Price(150_00), 100, TimeInForce::GTC);
/// multi.get_or_create(&msft).submit_limit(Side::Sell, Price(300_00), 200, TimeInForce::GTC);
///
/// assert_eq!(multi.get(&aapl).unwrap().best_ask(), Some(Price(150_00)));
/// assert_eq!(multi.get(&msft).unwrap().best_ask(), Some(Price(300_00)));
/// ```
#[derive(Clone, Debug, Default)]
pub struct MultiExchange {
    exchanges: FxHashMap<Symbol, Exchange>,
}

impl MultiExchange {
    /// Create an empty multi-exchange.
    pub fn new() -> Self {
        Self::default()
    }

    /// Get or create the exchange for a symbol.
    pub fn get_or_create(&mut self, symbol: &Symbol) -> &mut Exchange {
        self.exchanges.entry(*symbol).or_default()
    }

    /// Get a reference to the exchange for a symbol, if it exists.
    pub fn get(&self, symbol: &Symbol) -> Option<&Exchange> {
        self.exchanges.get(symbol)
    }

    /// Get a mutable reference to the exchange for a symbol, if it exists.
    pub fn get_mut(&mut self, symbol: &Symbol) -> Option<&mut Exchange> {
        self.exchanges.get_mut(symbol)
    }

    /// Iterator over all symbols that have exchanges.
    pub fn symbols(&self) -> impl Iterator<Item = &Symbol> {
        self.exchanges.keys()
    }

    /// Number of symbols.
    pub fn len(&self) -> usize {
        self.exchanges.len()
    }

    /// Returns true if no exchanges exist.
    pub fn is_empty(&self) -> bool {
        self.exchanges.is_empty()
    }

    /// Get the best bid and ask for all symbols.
    pub fn best_prices(&self) -> Vec<(Symbol, Option<Price>, Option<Price>)> {
        self.exchanges
            .iter()
            .map(|(sym, ex)| {
                let (bid, ask) = ex.best_bid_ask();
                (*sym, bid, ask)
            })
            .collect()
    }
}

#[cfg(test)]
#[allow(clippy::inconsistent_digit_grouping)]
mod tests {
    use super::*;
    use crate::{Side, TimeInForce};

    fn aapl() -> Symbol {
        Symbol::new("AAPL")
    }
    fn msft() -> Symbol {
        Symbol::new("MSFT")
    }

    #[test]
    fn create_and_query() {
        let mut multi = MultiExchange::new();
        multi
            .get_or_create(&aapl())
            .submit_limit(Side::Sell, Price(150_00), 100, TimeInForce::GTC);

        assert_eq!(multi.get(&aapl()).unwrap().best_ask(), Some(Price(150_00)));
        assert!(multi.get(&msft()).is_none());
    }

    #[test]
    fn multiple_symbols() {
        let mut multi = MultiExchange::new();
        multi
            .get_or_create(&aapl())
            .submit_limit(Side::Sell, Price(150_00), 100, TimeInForce::GTC);
        multi
            .get_or_create(&msft())
            .submit_limit(Side::Sell, Price(300_00), 200, TimeInForce::GTC);

        assert_eq!(multi.len(), 2);
        let prices = multi.best_prices();
        assert_eq!(prices.len(), 2);
    }

    #[test]
    fn symbols_iter() {
        let mut multi = MultiExchange::new();
        multi.get_or_create(&aapl());
        multi.get_or_create(&msft());

        let syms: Vec<&Symbol> = multi.symbols().collect();
        assert_eq!(syms.len(), 2);
    }

    #[test]
    fn empty() {
        let multi = MultiExchange::new();
        assert!(multi.is_empty());
        assert_eq!(multi.len(), 0);
    }

    #[test]
    fn independent_books() {
        let mut multi = MultiExchange::new();

        // Trade on AAPL
        multi
            .get_or_create(&aapl())
            .submit_limit(Side::Sell, Price(150_00), 100, TimeInForce::GTC);
        multi
            .get_or_create(&aapl())
            .submit_limit(Side::Buy, Price(150_00), 100, TimeInForce::GTC);

        // MSFT is untouched
        multi
            .get_or_create(&msft())
            .submit_limit(Side::Sell, Price(300_00), 200, TimeInForce::GTC);

        assert_eq!(multi.get(&aapl()).unwrap().trades().len(), 1);
        assert_eq!(multi.get(&msft()).unwrap().trades().len(), 0);
    }
}