lfest 0.77.0

A leveraged perpetual futures exchange for simulated trading and backtesting
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

use test_case::test_matrix;

use crate::{
    base, bba, mock_exchange_linear,
    prelude::{BaseCurrency, Error, LimitOrder, OrderId, Side, Trade},
    quote,
};

#[tracing_test::traced_test]
#[test_matrix([base!(1), base!(3), base!(5), base!(10)])]
fn amend_limit_order_qty(new_qty: BaseCurrency) {
    let mut exchange = mock_exchange_linear();

    assert!(exchange
        .update_state(1.into(), &bba!(quote!(100), quote!(101)))
        .unwrap()
        .is_empty());
    let order = LimitOrder::new(Side::Buy, quote!(100), base!(5)).unwrap();
    exchange.submit_limit_order(order.clone()).unwrap();
    assert_eq!(exchange.active_limit_orders().len(), 1);

    let new_order = LimitOrder::new(Side::Buy, quote!(100), new_qty).unwrap();
    let existing_id: OrderId = 0.into();
    exchange
        .amend_limit_order(existing_id, new_order.clone())
        .unwrap();
    let new_id: OrderId = 1.into();
    let replaced_order = exchange.active_limit_orders().get(&new_id).unwrap();
    assert_eq!(replaced_order.limit_price(), new_order.limit_price());
    assert_eq!(
        replaced_order.remaining_quantity(),
        new_order.remaining_quantity()
    );
    assert_eq!(replaced_order.side(), new_order.side());
}

#[tracing_test::traced_test]
#[test_matrix([base!(1), base!(2), base!(3)])]
fn amend_limit_order_qty_with_partial_fill_leading_to_cancel(new_qty: BaseCurrency) {
    let mut exchange = mock_exchange_linear();

    assert!(exchange
        .update_state(1.into(), &bba!(quote!(100), quote!(101)))
        .unwrap()
        .is_empty());
    let order = LimitOrder::new(Side::Buy, quote!(100), base!(5)).unwrap();
    exchange.submit_limit_order(order.clone()).unwrap();
    assert_eq!(exchange.active_limit_orders().len(), 1);

    exchange
        .update_state(
            0.into(),
            &Trade {
                price: quote!(99),
                quantity: base!(3),
                side: Side::Sell,
            },
        )
        .unwrap();

    let existing_id: OrderId = 0.into();
    assert_eq!(
        exchange
            .active_limit_orders()
            .get(&existing_id)
            .unwrap()
            .remaining_quantity(),
        base!(2)
    );

    let new_order = LimitOrder::new(Side::Buy, quote!(100), new_qty).unwrap();
    assert_eq!(
        exchange.amend_limit_order(existing_id, new_order.clone()),
        Err(Error::AmendQtyAlreadyFilled)
    );
}

#[tracing_test::traced_test]
#[test_matrix([base!(4), base!(5), base!(6)])]
fn amend_limit_order_qty_with_partial_fill(new_qty: BaseCurrency) {
    let mut exchange = mock_exchange_linear();

    assert!(exchange
        .update_state(1.into(), &bba!(quote!(100), quote!(101)))
        .unwrap()
        .is_empty());
    let order = LimitOrder::new(Side::Buy, quote!(100), base!(5)).unwrap();
    exchange.submit_limit_order(order.clone()).unwrap();
    assert_eq!(exchange.active_limit_orders().len(), 1);

    exchange
        .update_state(
            0.into(),
            &Trade {
                price: quote!(99),
                quantity: base!(3),
                side: Side::Sell,
            },
        )
        .unwrap();

    let existing_id: OrderId = 0.into();
    assert_eq!(
        exchange
            .active_limit_orders()
            .get(&existing_id)
            .unwrap()
            .remaining_quantity(),
        base!(2)
    );

    let new_order = LimitOrder::new(Side::Buy, quote!(100), new_qty).unwrap();
    exchange
        .amend_limit_order(existing_id, new_order.clone())
        .unwrap();
    let new_id: OrderId = 1.into();
    let replaced_order = exchange.active_limit_orders().get(&new_id).unwrap();
    assert_eq!(replaced_order.limit_price(), new_order.limit_price());
    assert_eq!(replaced_order.side(), new_order.side());
    let delta = new_qty - base!(5);
    assert_eq!(replaced_order.remaining_quantity(), base!(2) + delta);
}