1use nautilus_core::{
19 serialization::deserialize_empty_string_as_none, string::secret::SecretString,
20};
21use rust_decimal::Decimal;
22use serde::{
23 Deserialize, Deserializer, Serialize, Serializer,
24 de::{
25 DeserializeSeed, MapAccess, Visitor,
26 value::{BorrowedStrDeserializer, MapAccessDeserializer},
27 },
28};
29use serde_json::value::RawValue;
30use ustr::Ustr;
31use zeroize::Zeroize;
32
33use crate::common::{
34 enums::{
35 PolymarketEventType, PolymarketLiquiditySide, PolymarketOrderSide, PolymarketOrderStatus,
36 PolymarketOrderType, PolymarketOutcome, PolymarketTradeStatus,
37 },
38 models::PolymarketMakerOrder,
39 parse::{
40 deserialize_decimal_from_str, deserialize_optional_decimal_from_str,
41 serialize_decimal_as_str, serialize_optional_decimal_as_str,
42 },
43};
44
45#[derive(Clone, Debug, PartialEq, Eq)]
47pub struct PolymarketUserOrderStatus {
48 pub status: PolymarketOrderStatus,
49 pub reason: Option<String>,
50}
51
52impl PolymarketUserOrderStatus {
53 pub(crate) fn new(status: PolymarketOrderStatus, reason: Option<&str>) -> Self {
54 Self {
55 status,
56 reason: reason
57 .filter(|reason| !reason.trim().is_empty())
58 .map(str::to_string),
59 }
60 }
61}
62
63impl From<PolymarketOrderStatus> for PolymarketUserOrderStatus {
64 fn from(status: PolymarketOrderStatus) -> Self {
65 Self::new(status, None)
66 }
67}
68
69impl<'de> Deserialize<'de> for PolymarketUserOrderStatus {
70 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71 where
72 D: Deserializer<'de>,
73 {
74 let raw = String::deserialize(deserializer)?;
75
76 PolymarketOrderStatus::parse_wire(&raw)
77 .map(|(status, reason)| Self::new(status, reason))
78 .ok_or_else(|| {
79 serde::de::Error::custom(format!("Unknown PolymarketOrderStatus: {raw}"))
80 })
81 }
82}
83
84impl Serialize for PolymarketUserOrderStatus {
85 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
86 where
87 S: Serializer,
88 {
89 match self.reason.as_deref() {
90 Some(reason) => serializer.serialize_str(&format!("{}_{reason}", self.status)),
91 None => self.status.serialize(serializer),
92 }
93 }
94}
95
96#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
100pub struct PolymarketUserOrder {
101 pub asset_id: Ustr,
102 pub associate_trades: Option<Vec<String>>,
103 pub created_at: Option<String>,
104 pub expiration: Option<String>,
105 pub id: String,
106 pub maker_address: Option<Ustr>,
107 pub market: Ustr,
108 pub order_owner: Option<Ustr>,
109 pub order_type: Option<PolymarketOrderType>,
110 pub original_size: String,
111 pub outcome: Option<PolymarketOutcome>,
112 pub owner: Ustr,
113 pub price: String,
114 pub side: PolymarketOrderSide,
115 pub size_matched: String,
116 pub status: Option<PolymarketUserOrderStatus>,
117 pub timestamp: String,
118 #[serde(rename = "type")]
119 pub event_type: PolymarketEventType,
120}
121
122#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
126pub struct PolymarketUserTrade {
127 pub asset_id: Ustr,
128 pub bucket_index: u64,
129 pub fee_rate_bps: String,
130 pub id: String,
131 pub last_update: String,
132 pub maker_address: Ustr,
133 pub maker_orders: Vec<PolymarketMakerOrder>,
134 pub market: Ustr,
135 pub match_time: String,
136 pub outcome: PolymarketOutcome,
137 pub owner: Ustr,
138 pub price: String,
139 pub side: PolymarketOrderSide,
140 pub size: String,
141 pub status: PolymarketTradeStatus,
142 pub taker_order_id: String,
143 pub timestamp: String,
144 pub trade_owner: Ustr,
145 #[serde(
146 default,
147 deserialize_with = "deserialize_empty_string_as_none",
148 skip_serializing_if = "Option::is_none"
149 )]
150 pub transaction_hash: Option<String>,
151 pub trader_side: PolymarketLiquiditySide,
152 #[serde(rename = "type")]
153 pub event_type: PolymarketEventType,
154}
155
156#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
158pub struct PolymarketBookLevel {
159 pub price: String,
160 pub size: String,
161}
162
163#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
165pub struct PolymarketBookSnapshot {
166 pub market: Ustr,
167 pub asset_id: Ustr,
168 pub bids: Vec<PolymarketBookLevel>,
169 pub asks: Vec<PolymarketBookLevel>,
170 pub timestamp: String,
171 #[serde(default)]
172 pub hash: Option<String>,
173 #[serde(default)]
174 pub min_order_size: Option<String>,
175 #[serde(default)]
176 pub tick_size: Option<String>,
177 #[serde(default)]
178 pub neg_risk: Option<bool>,
179 #[serde(default)]
180 pub last_trade_price: Option<String>,
181 #[serde(default, skip_serializing_if = "Option::is_none")]
182 pub version: Option<String>,
183}
184
185#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
187pub struct PolymarketQuote {
188 pub asset_id: Ustr,
189 pub price: String,
190 pub side: PolymarketOrderSide,
191 pub size: String,
192 pub hash: String,
193 #[serde(default)]
194 pub best_bid: Option<String>,
195 #[serde(default)]
196 pub best_ask: Option<String>,
197}
198
199#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
201pub struct PolymarketQuotes {
202 pub market: Ustr,
203 pub price_changes: Vec<PolymarketQuote>,
204 pub timestamp: String,
205}
206
207#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
209pub struct PolymarketTrade {
210 pub market: Ustr,
211 pub asset_id: Ustr,
212 pub fee_rate_bps: String,
213 pub price: String,
214 pub side: PolymarketOrderSide,
215 pub size: String,
216 pub timestamp: String,
217 #[serde(default)]
218 pub transaction_hash: Option<String>,
219}
220
221#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
223pub struct PolymarketTickSizeChange {
224 pub market: Ustr,
225 pub asset_id: Ustr,
226 pub new_tick_size: String,
227 pub old_tick_size: String,
228 pub timestamp: String,
229}
230
231#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
233pub struct PolymarketNewMarketEvent {
234 pub id: String,
235 pub ticker: String,
236 pub slug: String,
237 pub title: String,
238 pub description: String,
239}
240
241#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
243pub struct PolymarketNewMarketFeeSchedule {
244 #[serde(
245 serialize_with = "serialize_decimal_as_str",
246 deserialize_with = "deserialize_decimal_from_str"
247 )]
248 pub exponent: Decimal,
249 #[serde(
250 serialize_with = "serialize_decimal_as_str",
251 deserialize_with = "deserialize_decimal_from_str"
252 )]
253 pub rate: Decimal,
254 pub taker_only: bool,
255 #[serde(
256 serialize_with = "serialize_decimal_as_str",
257 deserialize_with = "deserialize_decimal_from_str"
258 )]
259 pub rebate_rate: Decimal,
260}
261
262#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
266pub struct PolymarketNewMarket {
267 pub id: String,
268 pub question: String,
269 pub market: Ustr,
270 pub slug: String,
271 pub description: String,
272 pub assets_ids: Vec<String>,
273 pub outcomes: Vec<String>,
274 pub timestamp: String,
275 pub tags: Vec<String>,
276 pub condition_id: String,
277 pub active: bool,
278 pub clob_token_ids: Vec<String>,
279 #[serde(default)]
280 pub order_price_min_tick_size: Option<String>,
281 #[serde(default)]
282 pub group_item_title: Option<String>,
283 #[serde(default)]
284 pub event_message: Option<PolymarketNewMarketEvent>,
285 #[serde(default)]
286 pub sports_market_type: Option<String>,
287 #[serde(default)]
288 pub line: Option<String>,
289 #[serde(default)]
290 pub game_start_time: Option<String>,
291 #[serde(
292 default,
293 skip_serializing_if = "Option::is_none",
294 serialize_with = "serialize_optional_decimal_as_str",
295 deserialize_with = "deserialize_optional_decimal_from_str"
296 )]
297 pub taker_base_fee: Option<Decimal>,
298 #[serde(default)]
299 pub fees_enabled: Option<bool>,
300 #[serde(default)]
301 pub fee_schedule: Option<PolymarketNewMarketFeeSchedule>,
302}
303
304#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
308pub struct PolymarketMarketResolved {
309 pub id: String,
310 pub market: Ustr,
311 pub assets_ids: Vec<String>,
312 pub winning_asset_id: String,
313 pub winning_outcome: String,
314 pub timestamp: String,
315 pub tags: Vec<String>,
316}
317
318#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
323pub struct PolymarketBestBidAsk {
324 pub market: Ustr,
325 pub asset_id: Ustr,
326 pub best_bid: String,
327 pub best_ask: String,
328 pub spread: String,
329 pub timestamp: String,
330}
331
332#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
334#[serde(tag = "event_type")]
335pub enum MarketWsMessage {
336 #[serde(rename = "book")]
337 Book(PolymarketBookSnapshot),
338 #[serde(rename = "price_change")]
339 PriceChange(PolymarketQuotes),
340 #[serde(rename = "last_trade_price")]
341 LastTradePrice(PolymarketTrade),
342 #[serde(rename = "tick_size_change")]
343 TickSizeChange(PolymarketTickSizeChange),
344 #[serde(rename = "new_market")]
345 NewMarket(Box<PolymarketNewMarket>),
346 #[serde(rename = "market_resolved")]
347 MarketResolved(PolymarketMarketResolved),
348 #[serde(rename = "best_bid_ask")]
349 BestBidAsk(PolymarketBestBidAsk),
350}
351
352struct PayloadMapAccess<A> {
353 inner: A,
354}
355
356impl<A> PayloadMapAccess<A> {
357 const fn new(inner: A) -> Self {
358 Self { inner }
359 }
360}
361
362impl<'de, A> MapAccess<'de> for PayloadMapAccess<A>
363where
364 A: MapAccess<'de>,
365{
366 type Error = A::Error;
367
368 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
369 where
370 K: DeserializeSeed<'de>,
371 {
372 let Some(key) = self.inner.next_key::<&'de str>()? else {
373 return Ok(None);
374 };
375
376 if key == "event_type" {
377 return Err(serde::de::Error::duplicate_field("event_type"));
378 }
379
380 seed.deserialize(BorrowedStrDeserializer::new(key))
381 .map(Some)
382 }
383
384 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
385 where
386 V: DeserializeSeed<'de>,
387 {
388 self.inner.next_value_seed(seed)
389 }
390
391 fn size_hint(&self) -> Option<usize> {
392 self.inner.size_hint()
393 }
394}
395
396struct MarketWsMessageVisitor;
397
398impl<'de> Visitor<'de> for MarketWsMessageVisitor {
399 type Value = MarketWsMessage;
400
401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
402 formatter.write_str("a Polymarket market-channel message with event_type first")
403 }
404
405 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
406 where
407 A: MapAccess<'de>,
408 {
409 let Some(key) = map.next_key::<&str>()? else {
410 return Err(serde::de::Error::custom("expected event_type field"));
411 };
412
413 if key != "event_type" {
414 return Err(serde::de::Error::custom(
415 "event_type was not the first field",
416 ));
417 }
418
419 let event_type = map.next_value::<&str>()?;
420 let remaining = MapAccessDeserializer::new(PayloadMapAccess::new(map));
421 match event_type {
422 "book" => PolymarketBookSnapshot::deserialize(remaining).map(Self::Value::Book),
423 "price_change" => {
424 PolymarketQuotes::deserialize(remaining).map(Self::Value::PriceChange)
425 }
426 "last_trade_price" => {
427 PolymarketTrade::deserialize(remaining).map(Self::Value::LastTradePrice)
428 }
429 "tick_size_change" => {
430 PolymarketTickSizeChange::deserialize(remaining).map(Self::Value::TickSizeChange)
431 }
432 "new_market" => PolymarketNewMarket::deserialize(remaining)
433 .map(Box::new)
434 .map(Self::Value::NewMarket),
435 "market_resolved" => {
436 PolymarketMarketResolved::deserialize(remaining).map(Self::Value::MarketResolved)
437 }
438 "best_bid_ask" => {
439 PolymarketBestBidAsk::deserialize(remaining).map(Self::Value::BestBidAsk)
440 }
441 other => Err(serde::de::Error::unknown_variant(
442 other,
443 &[
444 "book",
445 "price_change",
446 "last_trade_price",
447 "tick_size_change",
448 "new_market",
449 "market_resolved",
450 "best_bid_ask",
451 ],
452 )),
453 }
454 }
455}
456
457impl MarketWsMessage {
458 pub fn parse(text: &str) -> serde_json::Result<Self> {
464 let mut deserializer = serde_json::Deserializer::from_str(text);
465 serde::Deserializer::deserialize_map(&mut deserializer, MarketWsMessageVisitor)
466 .and_then(|message| {
467 deserializer.end()?;
468 Ok(message)
469 })
470 .or_else(|_| Self::parse_reordered(text))
471 .or_else(|_| serde_json::from_str(text))
472 }
473
474 fn parse_reordered(text: &str) -> serde_json::Result<Self> {
475 let tag = serde_json::from_str::<MarketWsTag>(text)?;
476 match tag.event_type {
477 MarketWsEventTag::Book => serde_json::from_str(text).map(Self::Book),
478 MarketWsEventTag::PriceChange => serde_json::from_str(text).map(Self::PriceChange),
479 MarketWsEventTag::LastTradePrice => {
480 serde_json::from_str(text).map(Self::LastTradePrice)
481 }
482 MarketWsEventTag::TickSizeChange => {
483 serde_json::from_str(text).map(Self::TickSizeChange)
484 }
485 MarketWsEventTag::NewMarket => serde_json::from_str(text)
486 .map(Box::new)
487 .map(Self::NewMarket),
488 MarketWsEventTag::MarketResolved => {
489 serde_json::from_str(text).map(Self::MarketResolved)
490 }
491 MarketWsEventTag::BestBidAsk => serde_json::from_str(text).map(Self::BestBidAsk),
492 }
493 }
494}
495
496#[derive(Deserialize)]
497#[serde(rename_all = "snake_case")]
498enum MarketWsEventTag {
499 Book,
500 PriceChange,
501 LastTradePrice,
502 TickSizeChange,
503 NewMarket,
504 MarketResolved,
505 BestBidAsk,
506}
507
508#[derive(Deserialize)]
509struct MarketWsTag {
510 event_type: MarketWsEventTag,
511}
512
513#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
515#[serde(tag = "event_type")]
516pub enum UserWsMessage {
517 #[serde(rename = "order")]
518 Order(PolymarketUserOrder),
519 #[serde(rename = "trade")]
520 Trade(PolymarketUserTrade),
521 #[serde(rename = "auto_redeem")]
522 AutoRedeem,
523}
524
525struct UserWsMessageVisitor;
526
527impl<'de> Visitor<'de> for UserWsMessageVisitor {
528 type Value = UserWsMessage;
529
530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
531 formatter.write_str("a Polymarket user-channel message with event_type first")
532 }
533
534 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
535 where
536 A: MapAccess<'de>,
537 {
538 let Some(key) = map.next_key::<&str>()? else {
539 return Err(serde::de::Error::custom("expected event_type field"));
540 };
541
542 if key != "event_type" {
543 return Err(serde::de::Error::custom(
544 "event_type was not the first field",
545 ));
546 }
547
548 let event_type = map.next_value::<&str>()?;
549 let remaining = MapAccessDeserializer::new(PayloadMapAccess::new(map));
550 match event_type {
551 "order" => PolymarketUserOrder::deserialize(remaining).map(Self::Value::Order),
552 "trade" => PolymarketUserTrade::deserialize(remaining).map(Self::Value::Trade),
553 "auto_redeem" => {
554 serde::de::IgnoredAny::deserialize(remaining)?;
555 Ok(Self::Value::AutoRedeem)
556 }
557 other => Err(serde::de::Error::unknown_variant(
558 other,
559 &["order", "trade", "auto_redeem"],
560 )),
561 }
562 }
563}
564
565impl UserWsMessage {
566 pub fn parse(text: &str) -> serde_json::Result<Self> {
572 let mut deserializer = serde_json::Deserializer::from_str(text);
573 serde::Deserializer::deserialize_map(&mut deserializer, UserWsMessageVisitor)
574 .and_then(|message| {
575 deserializer.end()?;
576 Ok(message)
577 })
578 .or_else(|_| Self::parse_reordered(text))
579 .or_else(|_| serde_json::from_str(text))
580 }
581
582 pub fn parse_batch(text: &str) -> serde_json::Result<Vec<Self>> {
591 let elements: Vec<&RawValue> = serde_json::from_str(text)?;
594 let mut messages = Vec::with_capacity(elements.len());
595 let mut skipped = 0usize;
596
597 for element in elements {
598 if Self::has_unrecognized_event_type(element.get()) {
599 skipped += 1;
600 } else {
601 messages.push(serde_json::from_str(element.get())?);
602 }
603 }
604
605 if skipped > 0 {
606 log::debug!("Skipped {skipped} user WS message(s) with an unrecognized event_type");
607 }
608
609 Ok(messages)
610 }
611
612 pub(crate) fn has_unrecognized_event_type(text: &str) -> bool {
613 #[derive(Deserialize)]
615 struct EventTypeTag {
616 event_type: Option<String>,
617 }
618
619 serde_json::from_str::<EventTypeTag>(text).is_ok_and(|tag| {
620 tag.event_type.is_some_and(|event_type| {
621 !matches!(event_type.as_str(), "order" | "trade" | "auto_redeem")
622 })
623 })
624 }
625
626 fn parse_reordered(text: &str) -> serde_json::Result<Self> {
627 let tag = serde_json::from_str::<UserWsTag>(text)?;
628 match tag.event_type {
629 UserWsEventTag::Order => serde_json::from_str(text).map(Self::Order),
630 UserWsEventTag::Trade => serde_json::from_str(text).map(Self::Trade),
631 UserWsEventTag::AutoRedeem => serde_json::from_str(text),
632 }
633 }
634}
635
636#[derive(Deserialize)]
637#[serde(rename_all = "snake_case")]
638enum UserWsEventTag {
639 Order,
640 Trade,
641 AutoRedeem,
642}
643
644#[derive(Deserialize)]
645struct UserWsTag {
646 event_type: UserWsEventTag,
647}
648
649#[derive(Debug)]
651pub enum PolymarketWsMessage {
652 Market(MarketWsMessage),
653 User(UserWsMessage),
654 Reconnected {
659 shard_id: Option<usize>,
660 },
661}
662
663#[derive(Debug, Serialize, Zeroize)]
665pub struct PolymarketWsAuth {
666 #[serde(rename = "apiKey")]
667 pub api_key: SecretString,
668 pub secret: SecretString,
669 pub passphrase: SecretString,
670}
671
672#[derive(Debug, Serialize)]
678pub struct MarketInitialSubscribeRequest {
679 pub assets_ids: Vec<String>,
680 #[serde(rename = "type")]
681 pub msg_type: &'static str,
682 pub initial_dump: bool,
683 #[serde(skip_serializing_if = "std::ops::Not::not")]
684 pub custom_feature_enabled: bool,
685}
686
687#[derive(Debug, Serialize)]
693pub struct MarketSubscribeRequest {
694 pub assets_ids: Vec<String>,
695 pub operation: &'static str,
696 pub initial_dump: bool,
697 #[serde(skip_serializing_if = "std::ops::Not::not")]
698 pub custom_feature_enabled: bool,
699}
700
701#[derive(Debug, Serialize)]
705pub struct MarketUnsubscribeRequest {
706 pub assets_ids: Vec<String>,
707 pub operation: &'static str,
708}
709
710#[derive(Debug, Serialize, Zeroize)]
714pub struct UserSubscribeRequest {
715 pub auth: PolymarketWsAuth,
716 #[serde(rename = "type")]
717 #[zeroize(skip)]
718 pub msg_type: &'static str,
719}
720
721#[cfg(test)]
722mod tests {
723 use rstest::rstest;
724
725 use super::*;
726 use crate::common::enums::{
727 PolymarketEventType, PolymarketLiquiditySide, PolymarketOrderSide, PolymarketOrderStatus,
728 PolymarketOrderType, PolymarketOutcome, PolymarketTradeStatus,
729 };
730
731 #[rstest]
732 fn user_subscribe_request_matches_all_markets_wire_format() {
733 let request = UserSubscribeRequest {
734 auth: PolymarketWsAuth {
735 api_key: SecretString::from("fixture-key"),
736 secret: SecretString::from("fixture-secret"),
737 passphrase: SecretString::from("fixture-passphrase"),
738 },
739 msg_type: "user",
740 };
741
742 assert_eq!(
743 serde_json::to_value(request).unwrap(),
744 serde_json::json!({
745 "auth": {
746 "apiKey": "fixture-key",
747 "secret": "fixture-secret",
748 "passphrase": "fixture-passphrase",
749 },
750 "type": "user",
751 }),
752 );
753 }
754
755 fn load<T: serde::de::DeserializeOwned>(filename: &str) -> T {
756 let path = format!("test_data/{filename}");
757 let content = std::fs::read_to_string(path).expect("Failed to read test data");
758 serde_json::from_str(&content).expect("Failed to parse test data")
759 }
760
761 fn load_text(filename: &str) -> String {
762 let path = format!("test_data/{filename}");
763 std::fs::read_to_string(path).expect("Failed to read test data")
764 }
765
766 fn unknown_user_element() -> serde_json::Value {
767 let mut value: serde_json::Value = load("ws_user_auto_redeem.json");
768 value["event_type"] = "future_event".into();
769 value
770 }
771
772 #[rstest]
773 fn test_book_snapshot() {
774 let snap: PolymarketBookSnapshot = load("ws_book_snapshot.json");
775
776 assert_eq!(
777 snap.asset_id,
778 "71321045679252212594626385532706912750332728571942532289631379312455583992563"
779 );
780 assert_eq!(snap.bids.len(), 3);
781 assert_eq!(snap.asks.len(), 3);
782 assert_eq!(snap.bids[0].price, "0.48");
783 assert_eq!(snap.bids[0].size, "500.0");
784 assert_eq!(snap.asks[0].price, "0.53");
785 assert_eq!(snap.timestamp, "1703875200000");
786 assert!(snap.hash.is_none());
787 assert!(snap.min_order_size.is_none());
788 assert!(snap.tick_size.is_none());
789 assert!(snap.neg_risk.is_none());
790 assert!(snap.last_trade_price.is_none());
791 }
792
793 #[rstest]
794 fn test_book_snapshot_roundtrip() {
795 let snap: PolymarketBookSnapshot = load("ws_book_snapshot.json");
796 let json = serde_json::to_string(&snap).unwrap();
797 let snap2: PolymarketBookSnapshot = serde_json::from_str(&json).unwrap();
798 assert_eq!(snap, snap2);
799 }
800
801 #[rstest]
802 fn test_quotes() {
803 let quotes: PolymarketQuotes = load("ws_quotes.json");
804
805 assert_eq!(quotes.price_changes.len(), 2);
806 assert_eq!(quotes.price_changes[0].side, PolymarketOrderSide::Buy);
807 assert_eq!(quotes.price_changes[0].price, "0.51");
808 assert_eq!(quotes.price_changes[0].best_bid.as_deref(), Some("0.51"));
809 assert_eq!(quotes.price_changes[0].best_ask.as_deref(), Some("0.52"));
810 assert_eq!(quotes.price_changes[1].side, PolymarketOrderSide::Sell);
811 assert_eq!(quotes.timestamp, "1703875201000");
812 }
813
814 #[rstest]
815 fn test_last_trade() {
816 let trade: PolymarketTrade = load("ws_last_trade.json");
817
818 assert_eq!(trade.price, "0.51");
819 assert_eq!(trade.size, "25.0");
820 assert_eq!(trade.side, PolymarketOrderSide::Buy);
821 assert_eq!(trade.fee_rate_bps, "0");
822 assert_eq!(trade.timestamp, "1703875202000");
823 assert_eq!(
824 trade.transaction_hash.as_deref(),
825 Some("0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab")
826 );
827 }
828
829 #[rstest]
830 fn test_optional_market_hash_fields_default() {
831 let snap: PolymarketBookSnapshot = load("ws_book_snapshot_missing_hash.json");
832 let trade: PolymarketTrade = load("ws_last_trade_missing_transaction_hash.json");
833
834 assert!(snap.hash.is_none());
835 assert!(snap.min_order_size.is_none());
836 assert!(snap.tick_size.is_none());
837 assert!(snap.neg_risk.is_none());
838 assert!(snap.last_trade_price.is_none());
839 assert!(trade.transaction_hash.is_none());
840 }
841
842 #[rstest]
843 fn test_tick_size_change() {
844 let msg: PolymarketTickSizeChange = load("ws_tick_size_change.json");
845
846 assert_eq!(msg.new_tick_size, "0.01");
847 assert_eq!(msg.old_tick_size, "0.1");
848 assert_eq!(msg.timestamp, "1703875210000");
849 }
850
851 #[rstest]
852 fn test_user_order_placement() {
853 let order: PolymarketUserOrder = load("ws_user_order_placement.json");
854
855 assert_eq!(order.event_type, PolymarketEventType::Placement);
856 assert_eq!(
857 order.status.as_ref().map(|status| status.status),
858 Some(PolymarketOrderStatus::Live)
859 );
860 assert_eq!(order.side, PolymarketOrderSide::Buy);
861 assert_eq!(order.order_type, Some(PolymarketOrderType::GTC));
862 assert_eq!(order.outcome, Some(PolymarketOutcome::yes()));
863 assert_eq!(order.original_size, "100.0");
864 assert_eq!(order.size_matched, "0.0");
865 assert!(order.associate_trades.is_none());
866 assert!(order.expiration.is_none());
867 }
868
869 #[rstest]
870 fn test_user_order_update() {
871 let order: PolymarketUserOrder = load("ws_user_order_update.json");
872
873 assert_eq!(order.event_type, PolymarketEventType::Update);
874 assert_eq!(order.size_matched, "25.0");
875 assert_eq!(
876 order.associate_trades.as_deref(),
877 Some(&["trade-0xabcdef1234".to_string()][..])
878 );
879 }
880
881 #[rstest]
882 fn test_user_order_cancellation() {
883 let order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
884
885 assert_eq!(order.event_type, PolymarketEventType::Cancellation);
886 assert_eq!(
887 order.status.as_ref().map(|status| status.status),
888 Some(PolymarketOrderStatus::Canceled)
889 );
890 assert_eq!(order.size_matched, "0.0");
891 }
892
893 #[rstest]
894 fn test_user_order_status_preserves_rejection_reason() {
895 let raw = "UNMATCHED_invalid post-only order: order crosses book";
896 let status: PolymarketUserOrderStatus =
897 serde_json::from_str(&format!("\"{raw}\"")).unwrap();
898
899 assert_eq!(status.status, PolymarketOrderStatus::Unmatched);
900 assert_eq!(
901 status.reason.as_deref(),
902 Some("invalid post-only order: order crosses book")
903 );
904 assert_eq!(
905 serde_json::to_string(&status).unwrap(),
906 format!("\"{raw}\"")
907 );
908 }
909
910 #[rstest]
914 fn test_user_order_fok_killed() {
915 let msg: UserWsMessage = load("ws_user_order_fok_killed.json");
916
917 let UserWsMessage::Order(order) = msg else {
918 panic!("Expected UserWsMessage::Order");
919 };
920 assert_eq!(order.event_type, PolymarketEventType::Cancellation);
921 assert_eq!(
922 order.status.as_ref().map(|status| status.status),
923 Some(PolymarketOrderStatus::Canceled)
924 );
925 assert_eq!(
926 order
927 .status
928 .as_ref()
929 .and_then(|status| status.reason.as_deref()),
930 Some("order couldn't be fully filled. FOK orders are fully filled or killed.")
931 );
932 assert_eq!(order.order_type, Some(PolymarketOrderType::FOK));
933 assert_eq!(order.size_matched, "");
934 assert_eq!(order.created_at.as_deref(), Some(""));
935 assert_eq!(
936 order.outcome.as_ref().map(PolymarketOutcome::as_str),
937 Some("")
938 );
939 }
940
941 #[rstest]
942 fn test_user_trade() {
943 let trade: PolymarketUserTrade = load("ws_user_trade.json");
944
945 assert_eq!(trade.event_type, PolymarketEventType::Trade);
946 assert_eq!(trade.status, PolymarketTradeStatus::Confirmed);
947 assert_eq!(trade.side, PolymarketOrderSide::Buy);
948 assert_eq!(trade.trader_side, PolymarketLiquiditySide::Taker);
949 assert_eq!(trade.price, "0.5");
950 assert_eq!(trade.size, "25.0");
951 assert_eq!(trade.fee_rate_bps, "0");
952 assert_eq!(trade.bucket_index, 1);
953 assert_eq!(trade.maker_orders.len(), 1);
954 assert_eq!(
955 trade.transaction_hash.as_deref(),
956 Some("0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab")
957 );
958 assert_eq!(
959 trade.taker_order_id,
960 "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12"
961 );
962 }
963
964 #[rstest]
965 fn test_user_trade_missing_transaction_hash() {
966 let mut value: serde_json::Value = load("ws_user_trade.json");
967 value
968 .as_object_mut()
969 .expect("trade fixture should be an object")
970 .remove("transaction_hash");
971
972 let trade: PolymarketUserTrade =
973 serde_json::from_value(value).expect("trade fixture should deserialize");
974
975 assert!(trade.transaction_hash.is_none());
976 }
977
978 #[rstest]
979 fn test_market_ws_message_book() {
980 let msg: MarketWsMessage = load("ws_market_book_msg.json");
981
982 assert!(matches!(msg, MarketWsMessage::Book(_)));
983 if let MarketWsMessage::Book(snap) = msg {
984 assert_eq!(snap.bids.len(), 2);
985 assert_eq!(snap.asks.len(), 2);
986 assert_eq!(snap.timestamp, "1703875200000");
987 }
988 }
989
990 #[rstest]
991 #[case("ws_market_book_msg.json")]
992 #[case("ws_market_price_change_msg.json")]
993 #[case("ws_market_last_trade_msg.json")]
994 #[case("ws_market_tick_size_msg.json")]
995 #[case("ws_market_new_market_msg.json")]
996 #[case("ws_market_resolved_msg.json")]
997 #[case("ws_market_best_bid_ask_msg.json")]
998 fn test_market_ws_message_parse(#[case] filename: &str) {
999 let text = load_text(filename);
1000 let expected: MarketWsMessage =
1001 serde_json::from_str(&text).expect("market fixture should deserialize");
1002
1003 let actual = MarketWsMessage::parse(&text).expect("market fixture should parse");
1004
1005 assert_eq!(actual, expected);
1006 }
1007
1008 #[rstest]
1009 fn test_market_ws_message_parse_with_reordered_event_type() {
1010 let expected: MarketWsMessage = load("ws_market_book_msg.json");
1011 let mut value: serde_json::Value = load("ws_market_book_msg.json");
1012 let object = value
1013 .as_object_mut()
1014 .expect("market fixture should be an object");
1015 let event_type = object
1016 .remove("event_type")
1017 .expect("market fixture should contain event_type");
1018 object.insert("event_type".to_string(), event_type);
1019 let text = serde_json::to_string(&value).expect("market fixture should serialize");
1020
1021 assert!(!text.starts_with(r#"{"event_type":"#));
1022 assert_eq!(
1023 MarketWsMessage::parse(&text).expect("reordered market fixture should parse"),
1024 expected
1025 );
1026 }
1027
1028 #[rstest]
1029 fn test_market_ws_message_parse_rejects_duplicate_event_type() {
1030 let text = load_text("ws_market_book_msg.json").replacen(
1031 r#""event_type": "book","#,
1032 r#""event_type": "book", "event_type": "book","#,
1033 1,
1034 );
1035 let expected = serde_json::from_str::<MarketWsMessage>(&text)
1036 .expect_err("derived parser should reject a duplicate event_type");
1037 let actual = MarketWsMessage::parse(&text)
1038 .expect_err("optimized parser should reject a duplicate event_type");
1039
1040 assert_eq!(actual.to_string(), expected.to_string());
1041 }
1042
1043 #[rstest]
1044 fn test_market_ws_message_price_change() {
1045 let msg: MarketWsMessage = load("ws_market_price_change_msg.json");
1046
1047 assert!(matches!(msg, MarketWsMessage::PriceChange(_)));
1048 if let MarketWsMessage::PriceChange(quotes) = msg {
1049 assert_eq!(quotes.price_changes.len(), 1);
1050 }
1051 }
1052
1053 #[rstest]
1054 fn test_market_ws_message_last_trade_price() {
1055 let msg: MarketWsMessage = load("ws_market_last_trade_msg.json");
1056
1057 assert!(matches!(msg, MarketWsMessage::LastTradePrice(_)));
1058 if let MarketWsMessage::LastTradePrice(trade) = msg {
1059 assert_eq!(trade.price, "0.51");
1060 }
1061 }
1062
1063 #[rstest]
1064 fn test_market_ws_message_tick_size_change() {
1065 let msg: MarketWsMessage = load("ws_market_tick_size_msg.json");
1066
1067 assert!(matches!(msg, MarketWsMessage::TickSizeChange(_)));
1068 if let MarketWsMessage::TickSizeChange(change) = msg {
1069 assert_eq!(change.new_tick_size, "0.01");
1070 assert_eq!(change.old_tick_size, "0.1");
1071 }
1072 }
1073
1074 #[rstest]
1075 fn test_user_ws_message_order() {
1076 let msg: UserWsMessage = load("ws_user_order_msg.json");
1077
1078 let UserWsMessage::Order(order) = msg else {
1079 panic!("expected order message");
1080 };
1081 assert_eq!(
1082 order.asset_id,
1083 "10000000000000000000000000000000000000000000000000000000000000000000000000001"
1084 );
1085 assert_eq!(order.associate_trades, Some(Vec::new()));
1086 assert_eq!(order.created_at.as_deref(), Some(""));
1087 assert_eq!(order.expiration.as_deref(), Some("0"));
1088 assert_eq!(
1089 order.id,
1090 "0x1111111111111111111111111111111111111111111111111111111111111111"
1091 );
1092 assert_eq!(
1093 order.maker_address.as_ref().map(Ustr::as_str),
1094 Some("0x1111111111111111111111111111111111111111")
1095 );
1096 assert_eq!(
1097 order.market,
1098 "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
1099 );
1100 assert_eq!(
1101 order.order_owner.as_ref().map(Ustr::as_str),
1102 Some("11111111-2222-3333-4444-555555555555")
1103 );
1104 assert_eq!(order.order_type, Some(PolymarketOrderType::FOK));
1105 assert_eq!(order.original_size, "1");
1106 assert_eq!(
1107 order.outcome.as_ref().map(PolymarketOutcome::as_str),
1108 Some("")
1109 );
1110 assert_eq!(order.owner, "11111111-2222-3333-4444-555555555555");
1111 assert_eq!(order.price, "0.01");
1112 assert_eq!(order.side, PolymarketOrderSide::Buy);
1113 assert_eq!(order.size_matched, "");
1114 assert_eq!(
1115 order.status.as_ref().map(|status| status.status),
1116 Some(PolymarketOrderStatus::Canceled)
1117 );
1118 assert_eq!(order.timestamp, "1786179547007");
1119 assert_eq!(order.event_type, PolymarketEventType::Cancellation);
1120 }
1121
1122 #[rstest]
1123 fn test_user_ws_message_order_optional_fields_absent() {
1124 let json = r#"{
1126 "event_type":"order",
1127 "id":"order-1",
1128 "owner":"owner-1",
1129 "market":"market-1",
1130 "asset_id":"asset-1",
1131 "side":"SELL",
1132 "original_size":"2",
1133 "size_matched":"0",
1134 "price":"0.5",
1135 "type":"PLACEMENT",
1136 "timestamp":"1786179547008"
1137 }"#;
1138 let UserWsMessage::Order(order) = serde_json::from_str(json).unwrap() else {
1139 panic!("expected order message");
1140 };
1141
1142 assert_eq!(order.asset_id, "asset-1");
1143 assert!(order.associate_trades.is_none());
1144 assert!(order.created_at.is_none());
1145 assert!(order.expiration.is_none());
1146 assert_eq!(order.id, "order-1");
1147 assert!(order.maker_address.is_none());
1148 assert_eq!(order.market, "market-1");
1149 assert!(order.order_owner.is_none());
1150 assert!(order.order_type.is_none());
1151 assert_eq!(order.original_size, "2");
1152 assert!(order.outcome.is_none());
1153 assert_eq!(order.owner, "owner-1");
1154 assert_eq!(order.price, "0.5");
1155 assert_eq!(order.side, PolymarketOrderSide::Sell);
1156 assert_eq!(order.size_matched, "0");
1157 assert!(order.status.is_none());
1158 assert_eq!(order.timestamp, "1786179547008");
1159 assert_eq!(order.event_type, PolymarketEventType::Placement);
1160 }
1161
1162 #[rstest]
1163 fn test_user_ws_message_trade() {
1164 let msg: UserWsMessage = load("ws_user_trade_msg.json");
1165
1166 assert!(matches!(msg, UserWsMessage::Trade(_)));
1167 if let UserWsMessage::Trade(trade) = msg {
1168 assert_eq!(trade.event_type, PolymarketEventType::Trade);
1169 assert_eq!(trade.status, PolymarketTradeStatus::Confirmed);
1170 assert!(trade.transaction_hash.is_none());
1171 }
1172 }
1173
1174 #[rstest]
1175 #[case("ws_user_order_msg.json")]
1176 #[case("ws_user_order_fok_killed.json")]
1177 #[case("ws_user_trade_msg.json")]
1178 #[case("ws_user_auto_redeem.json")]
1179 fn test_user_ws_message_parse(#[case] filename: &str) {
1180 let text = load_text(filename);
1181 let expected: UserWsMessage =
1182 serde_json::from_str(&text).expect("user fixture should deserialize");
1183
1184 let actual = UserWsMessage::parse(&text).expect("user fixture should parse");
1185
1186 assert_eq!(actual, expected);
1187 }
1188
1189 #[rstest]
1190 #[case("ws_user_trade_msg.json")]
1191 #[case("ws_user_auto_redeem.json")]
1192 fn test_user_ws_message_parse_with_reordered_event_type(#[case] filename: &str) {
1193 let expected: UserWsMessage = load(filename);
1194 let mut value: serde_json::Value = load(filename);
1195 let object = value
1196 .as_object_mut()
1197 .expect("user fixture should be an object");
1198 let event_type = object
1199 .remove("event_type")
1200 .expect("user fixture should contain event_type");
1201 object.insert("event_type".to_string(), event_type);
1202 let text = serde_json::to_string(&value).expect("user fixture should serialize");
1203
1204 assert!(!text.starts_with(r#"{"event_type":"#));
1205 assert_eq!(
1206 UserWsMessage::parse(&text).expect("reordered user fixture should parse"),
1207 expected
1208 );
1209 }
1210
1211 #[rstest]
1212 #[case("ws_user_order_msg.json", "order")]
1213 #[case("ws_user_auto_redeem.json", "auto_redeem")]
1214 fn test_user_ws_message_parse_rejects_duplicate_event_type(
1215 #[case] filename: &str,
1216 #[case] event_type: &str,
1217 ) {
1218 let tag = format!(r#""event_type": "{event_type}""#);
1219 let text = load_text(filename).replacen(&tag, &format!("{tag}, {tag}"), 1);
1220 let expected = serde_json::from_str::<UserWsMessage>(&text)
1221 .expect_err("derived parser should reject a duplicate event_type");
1222 let actual = UserWsMessage::parse(&text)
1223 .expect_err("optimized parser should reject a duplicate event_type");
1224
1225 assert_eq!(actual.to_string(), expected.to_string());
1226 }
1227
1228 #[rstest]
1229 #[case::order_and_trade(false)]
1230 #[case::with_redemption(true)]
1231 fn test_user_ws_message_parse_batch(#[case] with_redemption: bool) {
1232 let mut value: serde_json::Value = load("ws_user_batch_msg.json");
1233 let mut expected: Vec<UserWsMessage> = load("ws_user_batch_msg.json");
1234
1235 if with_redemption {
1236 value
1237 .as_array_mut()
1238 .unwrap()
1239 .insert(1, load("ws_user_auto_redeem.json"));
1240 expected.insert(1, UserWsMessage::AutoRedeem);
1241 }
1242
1243 let text = serde_json::to_string(&value).unwrap();
1244
1245 let actual = UserWsMessage::parse_batch(&text).expect("user batch fixture should parse");
1246
1247 assert_eq!(actual, expected);
1248 }
1249
1250 #[rstest]
1251 fn test_user_ws_message_parse_batch_with_reordered_event_type() {
1252 let expected: Vec<UserWsMessage> = load("ws_user_batch_msg.json");
1253 let mut value: serde_json::Value = load("ws_user_batch_msg.json");
1254 let first = value
1255 .as_array_mut()
1256 .expect("user batch fixture should be an array")[0]
1257 .as_object_mut()
1258 .expect("user batch element should be an object");
1259 let event_type = first
1260 .remove("event_type")
1261 .expect("user batch element should contain event_type");
1262 first.insert("event_type".to_string(), event_type);
1263 let text = serde_json::to_string(&value).expect("user batch fixture should serialize");
1264
1265 assert_eq!(
1266 UserWsMessage::parse_batch(&text).expect("reordered user batch should parse"),
1267 expected
1268 );
1269 }
1270
1271 #[rstest]
1272 fn test_user_ws_message_parse_batch_rejects_invalid_element() {
1273 let mut value: serde_json::Value = load("ws_user_batch_msg.json");
1274 value
1275 .as_array_mut()
1276 .expect("user batch fixture should be an array")[1]
1277 .as_object_mut()
1278 .expect("user batch element should be an object")
1279 .remove("event_type");
1280 let text = serde_json::to_string(&value).expect("user batch fixture should serialize");
1281
1282 assert!(UserWsMessage::parse_batch(&text).is_err());
1283 }
1284
1285 #[rstest]
1288 fn test_user_ws_message_parse_batch_rejects_duplicate_event_type() {
1289 let element = load_text("ws_user_order_msg.json").replacen(
1290 r#""event_type": "order""#,
1291 r#""event_type": "order", "event_type": "order""#,
1292 1,
1293 );
1294 let text = format!("[{element}]");
1295
1296 assert!(UserWsMessage::parse_batch(&text).is_err());
1297 }
1298
1299 #[rstest]
1300 fn test_user_ws_message_parse_batch_skips_unknown_event_type() {
1301 let expected: Vec<UserWsMessage> = load("ws_user_batch_msg.json");
1302 let mut value: serde_json::Value = load("ws_user_batch_msg.json");
1303 let elements = value
1304 .as_array_mut()
1305 .expect("user batch fixture should be an array");
1306 elements.insert(1, unknown_user_element());
1307 let text = serde_json::to_string(&value).expect("user batch fixture should serialize");
1308
1309 let actual =
1310 UserWsMessage::parse_batch(&text).expect("batch with unknown event_type should parse");
1311
1312 assert_eq!(actual, expected);
1313 }
1314
1315 #[rstest]
1316 fn test_user_ws_message_parse_batch_all_unknown_event_types() {
1317 let text = serde_json::to_string(&serde_json::Value::Array(vec![
1318 unknown_user_element(),
1319 unknown_user_element(),
1320 ]))
1321 .expect("unknown batch should serialize");
1322
1323 let actual =
1324 UserWsMessage::parse_batch(&text).expect("batch of unknown event types should parse");
1325
1326 assert!(actual.is_empty());
1327 }
1328
1329 #[rstest]
1330 #[case::auto_redeem(load_text("ws_user_auto_redeem.json"), false)]
1331 #[case::unknown(unknown_user_element().to_string(), true)]
1332 #[case::order(load_text("ws_user_order_msg.json"), false)]
1333 #[case::trade(load_text("ws_user_trade_msg.json"), false)]
1334 #[case::missing_event_type(serde_json::json!({"type": "order"}).to_string(), false)]
1335 #[case::not_an_object(serde_json::json!([]).to_string(), false)]
1336 fn test_user_ws_message_has_unrecognized_event_type(
1337 #[case] text: String,
1338 #[case] expected: bool,
1339 ) {
1340 assert_eq!(UserWsMessage::has_unrecognized_event_type(&text), expected);
1341 }
1342
1343 #[rstest]
1344 fn test_market_ws_message_new_market() {
1345 let msg: MarketWsMessage = load("ws_market_new_market_msg.json");
1346 let raw: serde_json::Value = load("ws_market_new_market_msg.json");
1347
1348 let MarketWsMessage::NewMarket(nm) = msg else {
1349 panic!("expected new market message");
1350 };
1351 assert_eq!(nm.id, "market-001");
1352 assert_eq!(
1353 nm.question,
1354 "Map 1 Rounds Handicap: Sangal (-6.5) vs zeste (+6.5)"
1355 );
1356 assert_eq!(
1357 nm.market,
1358 "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
1359 );
1360 assert_eq!(nm.slug, "sanitized-new-market");
1361 assert_eq!(nm.description, raw["description"].as_str().unwrap());
1362 assert_eq!(
1363 nm.assets_ids,
1364 vec![
1365 "10000000000000000000000000000000000000000000000000000000000000000000000000001",
1366 "10000000000000000000000000000000000000000000000000000000000000000000000000002",
1367 ]
1368 );
1369 assert_eq!(nm.outcomes, vec!["Sangal", "zeste"]);
1370 assert_eq!(nm.timestamp, "1786179115414");
1371 assert!(nm.tags.is_empty());
1372 assert_eq!(
1373 nm.condition_id,
1374 "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
1375 );
1376 assert!(!nm.active);
1377 assert_eq!(nm.clob_token_ids, nm.assets_ids);
1378 assert_eq!(nm.order_price_min_tick_size.as_deref(), Some("0.01"));
1379 assert_eq!(
1380 nm.group_item_title.as_deref(),
1381 Some("Map 1 Rounds Handicap: Sangal (-6.5) vs zeste (+6.5)")
1382 );
1383 assert_eq!(
1384 nm.sports_market_type.as_deref(),
1385 Some("round_handicap_game_1")
1386 );
1387 assert_eq!(nm.line.as_deref(), Some("-6.5"));
1388 assert_eq!(
1389 nm.game_start_time.as_deref(),
1390 Some("2026-08-08 09:00:00+00")
1391 );
1392 assert_eq!(nm.taker_base_fee, Some(Decimal::from(1000)));
1393 assert_eq!(nm.fees_enabled, Some(true));
1394 let schedule = nm.fee_schedule.as_ref().expect("captured fee schedule");
1395 assert_eq!(schedule.exponent, Decimal::ONE);
1396 assert_eq!(schedule.rate, Decimal::new(5, 2));
1397 assert!(schedule.taker_only);
1398 assert_eq!(schedule.rebate_rate, Decimal::new(15, 2));
1399 let event = nm.event_message.as_ref().expect("captured event metadata");
1400 assert_eq!(event.id, "event-001");
1401 assert_eq!(event.ticker, "sanitized-event");
1402 assert_eq!(event.slug, "sanitized-event");
1403 assert_eq!(
1404 event.title,
1405 "Counter-Strike: Sangal vs zeste (BO3) - Esports World Cup Open Qualifier Group 16"
1406 );
1407 assert_eq!(
1408 event.description,
1409 raw["event_message"]["description"].as_str().unwrap()
1410 );
1411 }
1412
1413 #[rstest]
1414 fn test_market_ws_message_resolved() {
1415 let msg: MarketWsMessage = load("ws_market_resolved_msg.json");
1416
1417 assert!(matches!(msg, MarketWsMessage::MarketResolved(_)));
1418 if let MarketWsMessage::MarketResolved(mr) = msg {
1419 assert_eq!(mr.id, "1031769");
1420 assert_eq!(mr.winning_outcome, "Yes");
1421 assert_eq!(mr.assets_ids.len(), 2);
1422 assert_eq!(
1423 mr.winning_asset_id,
1424 "76043073756653678226373981964075571318267289248134717369284518995922789326425"
1425 );
1426 }
1427 }
1428
1429 #[rstest]
1430 fn test_market_ws_message_best_bid_ask() {
1431 let msg: MarketWsMessage = load("ws_market_best_bid_ask_msg.json");
1432
1433 assert!(matches!(msg, MarketWsMessage::BestBidAsk(_)));
1434 if let MarketWsMessage::BestBidAsk(bba) = msg {
1435 assert_eq!(bba.best_bid, "0.73");
1436 assert_eq!(bba.best_ask, "0.77");
1437 assert_eq!(bba.spread, "0.04");
1438 }
1439 }
1440}