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
132
133
134
135

use crate::{models::*, types::ClientError, ws_client::WsClient};
pub struct OrderbookNamespace<'a> {
    pub ws_client: &'a WsClient,
}
impl<'a> OrderbookNamespace<'a> {
    pub fn new(ws_client: &'a WsClient) -> Self {
        Self { ws_client }
    }
    pub async fn cancel(
        &self,
        params: CancelOrderRequest,
    ) -> Result<Order, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel", params_json).await
    }
    pub async fn cancel_algo_order(
        &self,
        params: CancelAlgoOrderRequest,
    ) -> Result<Order, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_algo_order", params_json).await
    }
    pub async fn cancel_all(
        &self,
        params: CancelAllRequest,
    ) -> Result<CancelAllResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_all", params_json).await
    }
    pub async fn cancel_all_algo_orders(
        &self,
        params: CancelAllAlgoOrdersRequest,
    ) -> Result<CancelAllAlgoOrdersResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_all_algo_orders", params_json).await
    }
    pub async fn cancel_all_trigger_orders(
        &self,
        params: CancelAllTriggerOrdersRequest,
    ) -> Result<CancelAllTriggerOrdersResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_all_trigger_orders", params_json).await
    }
    pub async fn cancel_by_instrument(
        &self,
        params: CancelByInstrumentRequest,
    ) -> Result<CancelByInstrumentResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_by_instrument", params_json).await
    }
    pub async fn cancel_by_label(
        &self,
        params: CancelByLabelRequest,
    ) -> Result<CancelByLabelResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_by_label", params_json).await
    }
    pub async fn cancel_by_nonce(
        &self,
        params: CancelByNonceRequest,
    ) -> Result<CancelByNonceResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_by_nonce", params_json).await
    }
    pub async fn cancel_trigger_order(
        &self,
        params: CancelTriggerOrderRequest,
    ) -> Result<Order, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/cancel_trigger_order", params_json).await
    }
    pub async fn get_algo_orders(
        &self,
        params: GetAlgoOrdersRequest,
    ) -> Result<Vec<Order>, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/get_algo_orders", params_json).await
    }
    pub async fn get_open_orders(
        &self,
        params: GetOpenOrdersRequest,
    ) -> Result<AggregatedOrdersResult, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/get_open_orders", params_json).await
    }
    pub async fn get_order(
        &self,
        params: GetOrderRequest,
    ) -> Result<Order, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/get_order", params_json).await
    }
    pub async fn get_trigger_orders(
        &self,
        params: GetTriggerOrdersRequest,
    ) -> Result<AggregatedTriggerOrdersResult, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/get_trigger_orders", params_json).await
    }
    pub async fn order(
        &self,
        params: CreateOrderRequest,
    ) -> Result<OrderCreatedResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/order", params_json).await
    }
    pub async fn order_debug(
        &self,
        params: CreateOrderRequest,
    ) -> Result<OrderDebugResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/order_debug", params_json).await
    }
    pub async fn order_quote(
        &self,
        params: OrderQuoteRequest,
    ) -> Result<OrderQuoteResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/order_quote", params_json).await
    }
    pub async fn replace(
        &self,
        params: ReplaceOrderRequest,
    ) -> Result<ReplaceOrderResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("private/replace", params_json).await
    }
    pub async fn public_order_quote(
        &self,
        params: OrderQuoteRequest,
    ) -> Result<OrderQuoteResponse, ClientError> {
        let params_json = serde_json::to_value(&params)?;
        self.ws_client.send_rpc("public/order_quote", params_json).await
    }
}