lfest 0.138.3

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

use crate::{
    mock_exchange_linear,
    prelude::*,
};

#[test]
fn cancel_limit_order() {
    let mut exchange = mock_exchange_linear();
    exchange
        .update_state(&Bba {
            bid: QuoteCurrency::new(100, 0),
            ask: QuoteCurrency::new(101, 0),
            timestamp_exchange_ns: 0.into(),
        })
        .unwrap();

    let limit_price = QuoteCurrency::new(100, 0);
    let qty = BaseCurrency::one();
    let order = LimitOrder::new(Side::Buy, limit_price, qty).unwrap();

    exchange.submit_limit_order(order.clone()).unwrap();

    let order_id: OrderId = 0.into();
    let meta = ExchangeOrderMeta::new(order_id, 0.into());
    let expected_order = order.into_pending(meta);

    assert_eq!(exchange.account().active_limit_orders().num_active(), 1);
    assert_eq!(
        exchange
            .account()
            .active_limit_orders()
            .get_by_id(order_id, Side::Buy)
            .unwrap(),
        &expected_order
    );
    assert_eq!(
        exchange.account().balances(),
        &Balances::builder()
            .equity(QuoteCurrency::new(1_000, 0))
            .total_fees_paid(QuoteCurrency::zero())
            .build()
    );
    assert!(exchange.account().position_margin().is_zero());
    assert_eq!(
        exchange.account().order_margin(),
        QuoteCurrency::new(100, 0)
    );
    // 1000 equity - 100 order margin - 0.02 reserved maker fee.
    assert_eq!(
        exchange.account().available_balance(),
        QuoteCurrency::new(89_998_000, 5)
    );

    exchange
        .cancel_limit_order(CancelBy::OrderId(order_id))
        .unwrap();
    assert!(exchange.account().active_limit_orders().is_empty());
    assert_eq!(
        exchange.account().balances(),
        &Balances::builder()
            .equity(QuoteCurrency::new(1000, 0))
            .total_fees_paid(QuoteCurrency::zero())
            .build()
    );
    assert_eq!(exchange.account().position_margin(), Zero::zero());
    assert_eq!(exchange.account().order_margin(), Zero::zero());

    let invalid_id: OrderId = 0.into();
    assert_eq!(
        exchange.cancel_limit_order(CancelBy::OrderId(invalid_id)),
        Err(CancelLimitOrderError::OrderIdNotFound(
            OrderIdNotFound::OrderId(invalid_id)
        ))
    );
}