rhyperliquid 0.2.0

Rust SDK and client for the Hyperliquid exchange API
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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

use rust_decimal::Decimal;
/// Response types for the info endpoints that are specific to perpetuals.
/// Additional information for endpoint responses can be found
/// here: `<https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals>`
use serde::{Deserialize, Serialize};

/// Response type for POST /info with type "perpDexs"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PerpetualDex {
    pub name: String,
    pub full_name: String,
    pub deployer: String,
    pub oracle_updater: Option<String>,
    pub fee_recipient: Option<String>,
    /// Array of [coin, cap] pairs
    pub asset_to_streaming_oi_cap: Vec<(String, String)>,
}

pub type PerpetualDexs = Vec<Option<PerpetualDex>>;

/// Response type for POST /info with type "meta"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AssetInfo {
    pub name: String,
    pub sz_decimals: u8,
    pub max_leverage: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub only_isolated: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_delisted: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// "strictIsolated" | "noCross"
    pub margin_mode: Option<String>,
    pub margin_table_id: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarginTier {
    pub lower_bound: String,
    pub max_leverage: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarginTable {
    pub description: String,
    pub margin_tiers: Vec<MarginTier>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PerpetualsMetadata {
    pub universe: Vec<AssetInfo>,
    /// Array of [id, table] pairs
    pub margin_tables: Vec<(u32, MarginTable)>,
}

/// Response type for POST /info with type "metaAndAssetCtxs"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AssetContext {
    #[serde(with = "rust_decimal::serde::str")]
    pub day_ntl_vlm: Decimal,
    #[serde(with = "rust_decimal::serde::str")]
    pub funding: Decimal,
    pub impact_pxs: Option<[String; 2]>,
    #[serde(with = "rust_decimal::serde::str")]
    pub mark_px: Decimal,
    #[serde(with = "rust_decimal::serde::str_option")]
    pub mid_px: Option<Decimal>,
    #[serde(with = "rust_decimal::serde::str")]
    pub open_interest: Decimal,
    #[serde(with = "rust_decimal::serde::str")]
    pub oracle_px: Decimal,
    #[serde(with = "rust_decimal::serde::str_option")]
    pub premium: Option<Decimal>,
    #[serde(with = "rust_decimal::serde::str")]
    pub prev_day_px: Decimal,
}

pub type MetaAndAssetContexts = (PerpetualsMetadata, Vec<AssetContext>);

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CumulativeFunding {
    pub all_time: String,
    pub since_change: String,
    pub since_open: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Leverage {
    /// "isolated" | "cross"
    #[serde(rename = "type")]
    pub type_: String,
    pub value: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Position {
    pub coin: String,
    pub cum_funding: CumulativeFunding,
    pub entry_px: String,
    pub leverage: Leverage,
    pub liquidation_px: String,
    pub margin_used: String,
    pub max_leverage: u32,
    pub position_value: String,
    pub return_on_equity: String,
    pub szi: String,
    pub unrealized_pnl: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AssetPosition {
    pub position: Position,
    /// "oneWay"
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarginSummary {
    pub account_value: String,
    pub total_margin_used: String,
    pub total_ntl_pos: String,
    pub total_raw_usd: String,
}

/// Response type for POST /info with type "clearinghouseState"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ClearinghouseState {
    pub asset_positions: Vec<AssetPosition>,
    pub cross_maintenance_margin_used: String,
    pub cross_margin_summary: MarginSummary,
    pub margin_summary: MarginSummary,
    pub time: u64,
    pub withdrawable: String,
}

/// Response type for POST /info with type "userFunding" | "userNonFundingLedgerUpdates"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FundingDelta {
    pub coin: String,
    pub funding_rate: String,
    pub szi: String,
    /// "funding"
    #[serde(rename = "type")]
    pub type_: String,
    pub usdc: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LedgerUpdate {
    pub delta: FundingDelta,
    pub hash: String,
    pub time: u64,
}

pub type LedgerUpdates = Vec<LedgerUpdate>;

/// Response type for POST /info with type "fundingHistory"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FundingRate {
    pub coin: String,
    pub funding_rate: String,
    pub premium: String,
    pub time: u64,
}

pub type FundingHistory = Vec<FundingRate>;

/// Response type for POST /info with type "predictedFundings"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PredictedFunding {
    pub funding_rate: String,
    pub next_funding_time: u64,
}

/// Array of [`venue_name`, `predicted_funding`] pairs
pub type VenueFundings = Vec<(String, PredictedFunding)>;

/// Array of [coin, `venue_fundings`] pairs
pub type PredictedFundings = Vec<(String, VenueFundings)>;

/// Response type for POST /info with type "perpsAtOpenInterestCap"
pub type PerpsAtOpenInterestCap = Vec<String>;

/// Response type for POST /info with type "perpDeployAuctionStatus"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PerpDeployAuctionStatus {
    pub start_time_seconds: u64,
    pub duration_seconds: u64,
    pub start_gas: String,
    pub current_gas: String,
    pub end_gas: Option<String>,
}

/// Response type for POST /info with type "activeAssetData"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActiveAssetData {
    pub user: String,
    pub coin: String,
    pub leverage: Leverage,
    pub max_trade_szs: [String; 2],
    pub available_to_trade: [String; 2],
    #[serde(with = "rust_decimal::serde::str")]
    pub mark_px: Decimal,
}

/// Response type for POST /info with type "perpDexLimits"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PerpDexLimits {
    #[serde(with = "rust_decimal::serde::str")]
    pub total_oi_cap: Decimal,
    #[serde(with = "rust_decimal::serde::str")]
    pub oi_sz_cap_per_perp: Decimal,
    #[serde(with = "rust_decimal::serde::str")]
    pub max_transfer_ntl: Decimal,
    /// Array of [coin, cap] pairs
    pub coin_to_oi_cap: Vec<(Decimal, Decimal)>,
}

/// Response type for POST /info with type "perpDexStatus"
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PerpDexStatus {
    #[serde(with = "rust_decimal::serde::str")]
    pub total_net_deposit: Decimal,
}