clob-sync 0.1.2

A synchronous, high-performance Central Limit Order Book implementation in Rust featuring an in-memory architecture with zero-cost abstractions and type-safe financial primitives for ultra-low latency trading applications.
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

#[test]
fn multiple_full_executions() {
    use clob_sync::prelude::*;

    let mut book =
        InMemoryOrderBookFactory::create_order_book(Symbol::from("AAPL"));

    let sell1 = Order::new(
        OrderType::Limit(Price::from(100)),
        Quantity::from(10u64),
        OrderSide::Sell,
        Symbol::from("AAPL"),
    )
    .with_id();

    let sell2 = Order::new(
        OrderType::Limit(Price::from(101)),
        Quantity::from(10u64),
        OrderSide::Sell,
        Symbol::from("AAPL"),
    )
    .with_id();

    let sell3 = Order::new(
        OrderType::Limit(Price::from(102)),
        Quantity::from(10u64),
        OrderSide::Sell,
        Symbol::from("AAPL"),
    )
    .with_id();

    let sell4 = Order::new(
        OrderType::Limit(Price::from(103)),
        Quantity::from(10u64),
        OrderSide::Sell,
        Symbol::from("AAPL"),
    )
    .with_id();

    book.execute(&sell1).unwrap();
    book.execute(&sell2).unwrap();
    book.execute(&sell3).unwrap();
    book.execute(&sell4).unwrap();

    let market_buy = Order::new(
        OrderType::Market,
        Quantity::from(50u64),
        OrderSide::Buy,
        Symbol::from("AAPL"),
    )
    .with_id();

    let result = book.execute(&market_buy).unwrap();

    match result {
        Executions::Executed(executions) => {
            assert_eq!(executions.len(), 8);

            let mut full_execution_ids: Vec<OrderId> = Vec::new();
            let mut partial_execution_ids: Vec<OrderId> = Vec::new();

            for exec in executions.iter() {
                match exec {
                    Execution::FullExecution(id) => {
                        full_execution_ids.push(*id);
                    }
                    Execution::PartialExecution(id, qty) => {
                        partial_execution_ids.push(*id);
                        assert!(!qty.is_zero());
                    }
                    _ => panic!("unexpected execution type"),
                }
            }

            assert_eq!(full_execution_ids.len(), 4);
            assert_eq!(partial_execution_ids.len(), 4);

            let unique_partial_ids: Vec<_> = partial_execution_ids.to_vec();
            assert!(
                unique_partial_ids
                    .iter()
                    .all(|id| *id == unique_partial_ids[0]),
                "All partial executions should reference the same incoming order UUID"
            );
        }
        Executions::AllocatedNoExecutions => {
            panic!("expected executions, got none");
        }
    }
}