derive-rs 0.1.12

Rust SDK for Derive.xyz
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

use bigdecimal::{BigDecimal, FromPrimitive};
use derive_rs::{
    actions::{OrderArgs, ReplaceArgs},
    models::{
        CancelOrderRequest, Direction, GetInstrumentRequest, GetTickerRequest, OrderStatus,
        OrderType, TimeInForce,
    },
};
mod common;

#[tokio::test]
async fn test_ws_order_lifecycle() {
    let ws_client = common::get_test_ws_client().await;
    ws_client.login().await.expect("Login failed");

    let instrument_name = "ETH-PERP".to_string();

    let params = GetTickerRequest::builder()
        .instrument_name(instrument_name.clone())
        .try_into()
        .expect("Failed to build GetInstrumentRequest");

    let result = ws_client.rpc().market_data().get_ticker(params).await;
    assert!(result.is_ok(), "Get Ticker failed: {:?}", result.err());
    let ticker = result.unwrap();

    let instrument_params = GetInstrumentRequest::builder()
        .instrument_name(instrument_name.clone())
        .try_into()
        .expect("Failed to build GetInstrumentRequest");
    let instrument_result = ws_client
        .rpc()
        .market_data()
        .get_instrument(instrument_params)
        .await;
    assert!(
        instrument_result.is_ok(),
        "Get Instrument failed: {:?}",
        instrument_result.err()
    );
    let instrument = instrument_result.unwrap();

    let order_args = OrderArgs::builder()
        .instrument_name(instrument_name.clone())
        .amount(instrument.minimum_amount.clone())
        .limit_price(ticker.i.clone() * BigDecimal::from_f64(0.99).expect("Failed to make offset"))
        .direction(Direction::Buy)
        .order_type(OrderType::Limit)
        .time_in_force(TimeInForce::Gtc)
        .build();

    let order_result = ws_client.orders().place(order_args).await;

    assert!(
        order_result.is_ok(),
        "Order failed: {:?}",
        order_result.err()
    );

    // we fetch the order from the rpc to be sure it was created correctly.
    let order_id = order_result.as_ref().unwrap().order.order_id.clone();
    let existing_order = ws_client.orders().get_order(order_id).await;
    assert!(
        existing_order.is_ok(),
        "Get Order by ID failed: {:?}",
        existing_order.err()
    );
    // we ensure it is is open;
    let order = existing_order.unwrap();
    assert!(
        order.order_status == OrderStatus::Open,
        "Order is not open: {:?}",
        order.order_status
    );
    // we now update the order.

    let order = order_result.unwrap();

    println!("Order created: {:?}", order);
    // sleep(std::time::Duration::from_secs(1)).await;

    let replace_params = ReplaceArgs::builder()
        .instrument_name(instrument_name.clone())
        .amount(
            instrument.minimum_amount * BigDecimal::from_f64(2.0).expect("Failed to make offset"),
        )
        .limit_price(ticker.i.clone() - BigDecimal::from_f64(1.0).expect("Failed to parse 1.01"))
        .direction(Direction::Buy)
        .order_type(OrderType::Limit)
        .time_in_force(TimeInForce::Gtc)
        .order_id_to_cancel(
            order
                .order
                .order_id
                .clone()
                .parse()
                .expect("Failed to parse order_id"),
        )
        // .nonce_to_cancel(order.order.nonce.parse().expect("Nonce is incorrect"))
        .build();

    let replace_result = ws_client.orders().replace(replace_params).await;
    assert!(
        replace_result.is_ok(),
        "Replace Order failed: {:?}",
        replace_result.err()
    );

    let replacement_order = replace_result.unwrap();

    // we now have an order, we can cancel it
    let cancel_params = CancelOrderRequest::builder()
        .instrument_name(instrument_name)
        .order_id(
            replacement_order
                .order
                .expect("We should have a replacement order")
                .order_id
                .clone(),
        )
        .subaccount_id(ws_client.subaccount_id.expect("Must have a subaccount_id"))
        .try_into()
        .expect("Failed to build CancelOrderRequest");

    let cancel_result = ws_client.rpc().orderbook().cancel(cancel_params).await;
    assert!(
        cancel_result.is_ok(),
        "Cancel Order failed: {:?}",
        cancel_result.err()
    );
}