deribit 0.3.3

Rust client for deribit. Please look at tests/examples for detailed usages.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

use crate::models::{AssetKind, Currency, Direction};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

crate::define_request! {
    Name => GetPositions;
    Method => "private/get_positions";
    Request => {
        pub currency: Currency,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub kind: Option<AssetKind>,
    };
    Response => Vec<GetPositionsResponse>;
}

impl GetPositionsRequest {
    pub fn all(currency: Currency) -> Self {
        Self {
            currency,
            kind: None,
        }
    }

    pub fn futures(currency: Currency) -> Self {
        Self {
            currency,
            kind: Some(AssetKind::Future),
        }
    }

    pub fn options(currency: Currency) -> Self {
        Self {
            currency,
            kind: Some(AssetKind::Option),
        }
    }
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct GetPositionsResponse {
    pub average_price: f64,
    pub average_price_usd: Option<f64>,
    pub delta: f64,
    pub direction: Direction,
    pub estimated_liquidation_price: Option<f64>,
    pub floating_profit_loss: f64,
    pub floating_profit_loss_usd: Option<f64>,
    pub index_price: f64,
    pub initial_margin: f64,
    pub instrument_name: String,
    pub kind: AssetKind,
    pub maintenance_margin: f64,
    pub mark_price: f64,
    pub open_orders_margin: f64,
    pub realized_profit_loss: f64,
    pub settlement_price: f64,
    pub size: f64,
    pub size_currency: Option<f64>,
    pub total_profit_loss: f64,
}

crate::define_request! {
    Name => GetAccountSummary;
    Method => "private/get_account_summary";
    Request => {
        pub currency: Currency,
        pub extended: bool,
    };
    Response => {
        pub options_gamma: f64,
        pub projected_maintenance_margin: Option<f64>,
        pub system_name: Option<String>,
        pub margin_balance: f64,
        pub tfa_enabled: Option<bool>,
        pub username: Option<String>,
        pub equity: f64,
        pub futures_pl: f64,
        pub options_session_upl: f64,
        pub id: Option<u64>,
        pub options_vega: f64,
        pub session_funding: Option<f64>,
        pub currency: Currency,
        pub r#type: Option<String>,
        pub futures_session_rpl: f64,
        pub options_theta: f64,
        pub portfolio_margin_enabled: Option<bool>,
        pub session_rpl: f64,
        pub delta_total: f64,
        pub options_pl: f64,
        pub available_withdrawal_funds: f64,
        pub maintenance_margin: f64,
        pub initial_margin: f64,
        pub futures_session_upl: f64,
        pub options_session_rpl: f64,
        pub available_funds: f64,
        pub email: Option<String>,
        pub session_upl: f64,
        pub total_pl: f64,
        pub options_delta: f64,
        pub balance: f64,
        pub projected_initial_margin: Option<f64>,
        pub deposit_address: Option<String>,
        pub referrer_id: Option<String>,
    };
}

impl GetAccountSummaryRequest {
    pub fn abridged(currency: Currency) -> Self {
        Self {
            currency,
            ..Default::default()
        }
    }
    pub fn extended(currency: Currency) -> Self {
        Self {
            currency,
            extended: true,
        }
    }
}

crate::define_request! {
    Name => GetSubaccounts;
    Method => "private/get_subaccounts";
    Request => {
        pub with_portfolio: bool,
    };
    Response => Vec<GetSubaccountsResponse>;
}

impl GetSubaccountsRequest {
    pub fn new() -> Self {
        Self {
            with_portfolio: false,
        }
    }

    pub fn with_portfolio() -> Self {
        Self {
            with_portfolio: true,
        }
    }
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct Portfolio {
    pub available_funds: f64,
    pub available_withdrawal_funds: f64,
    pub balance: f64,
    pub currency: Currency,
    pub equity: f64,
    pub initial_margin: f64,
    pub maintenance_margin: f64,
    pub margin_balance: f64,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct GetSubaccountsResponse {
    pub email: String,
    pub id: u64,
    pub is_password: bool,
    pub login_enabled: bool,
    pub not_confirmed_email: Option<String>,
    pub portfolio: HashMap<Currency, Portfolio>,
    pub receive_notifications: bool,
    pub system_name: String,
    pub tfa_enabled: Option<bool>,
    pub r#type: String,
    pub username: String,
    pub referrals_count: u64,
    pub security_keys_enabled: bool,
}