nautilus_hyperliquid/websocket/
enums.rs1use serde::{Deserialize, Serialize};
17use strum::{AsRefStr, Display, EnumIter, EnumString};
18
19#[derive(
21 Clone,
22 Debug,
23 Display,
24 PartialEq,
25 Eq,
26 Hash,
27 AsRefStr,
28 EnumIter,
29 EnumString,
30 Serialize,
31 Deserialize,
32)]
33pub enum HyperliquidWsChannel {
34 #[serde(rename = "subscriptionResponse")]
35 SubscriptionResponse,
36 #[serde(rename = "trades")]
37 Trades,
38 #[serde(rename = "l2Book")]
39 L2Book,
40 #[serde(rename = "bbo")]
41 Bbo,
42 #[serde(rename = "candle")]
43 Candle,
44 #[serde(rename = "allMids")]
45 AllMids,
46 #[serde(rename = "allDexsAssetCtxs")]
47 AllDexsAssetCtxs,
48 #[serde(rename = "notification")]
49 Notification,
50 #[serde(rename = "orderUpdates")]
51 OrderUpdates,
52 #[serde(rename = "userEvents")]
53 UserEvents,
54 #[serde(rename = "userFills")]
55 UserFills,
56 #[serde(rename = "userFundings")]
57 UserFundings,
58 #[serde(rename = "userNonFundingLedgerUpdates")]
59 UserNonFundingLedgerUpdates,
60 #[serde(rename = "activeAssetCtx")]
61 ActiveAssetCtx,
62 #[serde(rename = "activeSpotAssetCtx")]
63 ActiveSpotAssetCtx,
64 #[serde(rename = "activeAssetData")]
65 ActiveAssetData,
66 #[serde(rename = "userTwapSliceFills")]
67 UserTwapSliceFills,
68 #[serde(rename = "userTwapHistory")]
69 UserTwapHistory,
70 #[serde(rename = "webData2")]
71 WebData2,
72 #[serde(rename = "user")]
74 User,
75 #[serde(rename = "post")]
76 Post,
77 #[serde(rename = "pong")]
78 Pong,
79 #[serde(rename = "error")]
80 Error,
81 #[serde(rename = "clearinghouseState")]
82 ClearinghouseState,
83 #[serde(rename = "spotState")]
84 SpotState,
85}
86
87impl HyperliquidWsChannel {
88 pub fn as_str(&self) -> &'static str {
90 match self {
91 Self::SubscriptionResponse => "subscriptionResponse",
92 Self::Trades => "trades",
93 Self::L2Book => "l2Book",
94 Self::Bbo => "bbo",
95 Self::Candle => "candle",
96 Self::AllMids => "allMids",
97 Self::AllDexsAssetCtxs => "allDexsAssetCtxs",
98 Self::Notification => "notification",
99 Self::OrderUpdates => "orderUpdates",
100 Self::UserEvents => "userEvents",
101 Self::UserFills => "userFills",
102 Self::UserFundings => "userFundings",
103 Self::UserNonFundingLedgerUpdates => "userNonFundingLedgerUpdates",
104 Self::ActiveAssetCtx => "activeAssetCtx",
105 Self::ActiveSpotAssetCtx => "activeSpotAssetCtx",
106 Self::ActiveAssetData => "activeAssetData",
107 Self::UserTwapSliceFills => "userTwapSliceFills",
108 Self::UserTwapHistory => "userTwapHistory",
109 Self::WebData2 => "webData2",
110 Self::User => "user",
111 Self::Post => "post",
112 Self::Pong => "pong",
113 Self::Error => "error",
114 Self::ClearinghouseState => "clearinghouseState",
115 Self::SpotState => "spotState",
116 }
117 }
118
119 pub fn is_public(&self) -> bool {
121 matches!(
122 self,
123 Self::SubscriptionResponse
124 | Self::Trades
125 | Self::L2Book
126 | Self::Bbo
127 | Self::Candle
128 | Self::AllMids
129 | Self::AllDexsAssetCtxs
130 | Self::ActiveAssetCtx
131 | Self::ActiveSpotAssetCtx
132 | Self::Notification
133 | Self::Pong
134 | Self::Error
135 )
136 }
137
138 pub fn is_private(&self) -> bool {
140 !self.is_public()
141 }
142
143 pub fn from_wire_str(s: &str) -> Option<Self> {
145 serde_json::from_value(serde_json::Value::String(s.to_string())).ok()
146 }
147}
148
149#[cfg(test)]
150mod tests {
151 use std::str::FromStr;
152
153 use rstest::rstest;
154 use serde_json;
155 use strum::IntoEnumIterator;
156
157 use super::*;
158
159 #[rstest]
160 #[case(HyperliquidWsChannel::Trades, r#""trades""#)]
161 #[case(HyperliquidWsChannel::L2Book, r#""l2Book""#)]
162 #[case(HyperliquidWsChannel::UserFills, r#""userFills""#)]
163 #[case(HyperliquidWsChannel::Bbo, r#""bbo""#)]
164 #[case(
165 HyperliquidWsChannel::SubscriptionResponse,
166 r#""subscriptionResponse""#
167 )]
168 fn test_channel_serialization(#[case] channel: HyperliquidWsChannel, #[case] expected: &str) {
169 assert_eq!(serde_json::to_string(&channel).unwrap(), expected);
170 }
171
172 #[rstest]
173 #[case(r#""trades""#, HyperliquidWsChannel::Trades)]
174 #[case(r#""l2Book""#, HyperliquidWsChannel::L2Book)]
175 #[case(r#""userEvents""#, HyperliquidWsChannel::UserEvents)]
176 #[case(r#""bbo""#, HyperliquidWsChannel::Bbo)]
177 #[case(r#""pong""#, HyperliquidWsChannel::Pong)]
178 fn test_channel_deserialization(#[case] json: &str, #[case] expected: HyperliquidWsChannel) {
179 assert_eq!(
180 serde_json::from_str::<HyperliquidWsChannel>(json).unwrap(),
181 expected
182 );
183 }
184
185 #[rstest]
186 #[case(HyperliquidWsChannel::Trades, "trades")]
187 #[case(HyperliquidWsChannel::L2Book, "l2Book")]
188 #[case(HyperliquidWsChannel::UserFills, "userFills")]
189 #[case(
190 HyperliquidWsChannel::UserNonFundingLedgerUpdates,
191 "userNonFundingLedgerUpdates"
192 )]
193 #[case(HyperliquidWsChannel::Bbo, "bbo")]
194 fn test_as_str_method(#[case] channel: HyperliquidWsChannel, #[case] expected: &str) {
195 assert_eq!(channel.as_str(), expected);
196 }
197
198 #[rstest]
199 fn test_display_trait() {
200 assert_eq!(format!("{}", HyperliquidWsChannel::Trades), "Trades");
201 assert_eq!(format!("{}", HyperliquidWsChannel::L2Book), "L2Book");
202 assert_eq!(format!("{}", HyperliquidWsChannel::UserFills), "UserFills");
203 }
204
205 #[rstest]
206 fn test_is_public_channel() {
207 assert!(HyperliquidWsChannel::Trades.is_public());
208 assert!(HyperliquidWsChannel::L2Book.is_public());
209 assert!(HyperliquidWsChannel::Bbo.is_public());
210 assert!(HyperliquidWsChannel::SubscriptionResponse.is_public());
211 assert!(HyperliquidWsChannel::Pong.is_public());
212
213 assert!(!HyperliquidWsChannel::OrderUpdates.is_public());
214 assert!(!HyperliquidWsChannel::UserEvents.is_public());
215 assert!(!HyperliquidWsChannel::UserFills.is_public());
216 assert!(!HyperliquidWsChannel::UserFundings.is_public());
217 assert!(!HyperliquidWsChannel::UserNonFundingLedgerUpdates.is_public());
218 assert!(!HyperliquidWsChannel::Post.is_public());
219 }
220
221 #[rstest]
222 fn test_is_private_channel() {
223 assert!(!HyperliquidWsChannel::Trades.is_private());
224 assert!(!HyperliquidWsChannel::L2Book.is_private());
225 assert!(!HyperliquidWsChannel::Bbo.is_private());
226
227 assert!(HyperliquidWsChannel::OrderUpdates.is_private());
228 assert!(HyperliquidWsChannel::UserEvents.is_private());
229 assert!(HyperliquidWsChannel::UserFills.is_private());
230 assert!(HyperliquidWsChannel::UserFundings.is_private());
231 assert!(HyperliquidWsChannel::UserNonFundingLedgerUpdates.is_private());
232 assert!(HyperliquidWsChannel::Post.is_private());
233 }
234
235 #[rstest]
236 fn test_enum_iter() {
237 let channels: Vec<HyperliquidWsChannel> = HyperliquidWsChannel::iter().collect();
238 assert_eq!(channels.len(), 25);
239 assert!(channels.contains(&HyperliquidWsChannel::Trades));
240 assert!(channels.contains(&HyperliquidWsChannel::L2Book));
241 assert!(channels.contains(&HyperliquidWsChannel::UserFills));
242 assert!(channels.contains(&HyperliquidWsChannel::Candle));
243 assert!(channels.contains(&HyperliquidWsChannel::AllMids));
244 assert!(channels.contains(&HyperliquidWsChannel::AllDexsAssetCtxs));
245 assert!(channels.contains(&HyperliquidWsChannel::Notification));
246 assert!(channels.contains(&HyperliquidWsChannel::ClearinghouseState));
247 assert!(channels.contains(&HyperliquidWsChannel::SpotState));
248 }
249
250 #[rstest]
251 fn test_from_str() {
252 assert_eq!(
253 HyperliquidWsChannel::from_str("Trades").unwrap(),
254 HyperliquidWsChannel::Trades
255 );
256 assert_eq!(
257 HyperliquidWsChannel::from_str("L2Book").unwrap(),
258 HyperliquidWsChannel::L2Book
259 );
260 assert_eq!(
261 HyperliquidWsChannel::from_str("UserFills").unwrap(),
262 HyperliquidWsChannel::UserFills
263 );
264
265 assert!(HyperliquidWsChannel::from_str("InvalidChannel").is_err());
266 }
267}