Skip to main content

nautilus_polymarket/websocket/
messages.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! WebSocket message types for the Polymarket CLOB API.
17
18use 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/// A user-channel order status and its optional venue reason suffix.
46#[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/// A user order status update from the WebSocket user channel.
97///
98/// References: <https://docs.polymarket.com/developers/CLOB/websocket/user-channel#order-message>
99#[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/// A user trade update from the WebSocket user channel.
123///
124/// References: <https://docs.polymarket.com/developers/CLOB/websocket/user-channel>
125#[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/// A single price level in an order book snapshot.
157#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
158pub struct PolymarketBookLevel {
159    pub price: String,
160    pub size: String,
161}
162
163/// An order book snapshot from the WebSocket market channel.
164#[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/// A single price change entry within a quotes message.
186#[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/// A price change (quotes) message from the WebSocket market channel.
200#[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/// A last trade price message from the WebSocket market channel.
208#[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/// A tick size change notification from the WebSocket market channel.
222#[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/// Event metadata embedded in a new market notification.
232#[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/// Fee configuration observed in a new market notification.
242#[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/// A new market notification from the WebSocket market channel.
263///
264/// Only received when `subscribe_new_markets` is enabled.
265#[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/// A market resolved notification from the WebSocket market channel.
305///
306/// Only received when `subscribe_new_markets` is enabled.
307#[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/// A best bid/ask notification from the WebSocket market channel.
319///
320/// Only received when `subscribe_new_markets` is enabled.
321/// The data adapter emits these events as quote ticks for active quote subscriptions.
322#[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/// An envelope for tagged WebSocket market channel messages.
333#[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    /// Parses a market-channel JSON message.
459    ///
460    /// # Errors
461    ///
462    /// Returns an error if `text` is not a valid market message.
463    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/// An envelope for tagged WebSocket user channel messages.
514#[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    /// Parses a user-channel JSON message.
567    ///
568    /// # Errors
569    ///
570    /// Returns an error if `text` is not a valid user message.
571    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    /// Parses a batch of user-channel JSON messages.
583    ///
584    /// Elements carrying an unrecognized `event_type` are skipped so that a single unknown
585    /// message cannot discard the valid `order` and `trade` messages batched alongside it.
586    ///
587    /// # Errors
588    ///
589    /// Returns an error if `text` is not a valid user-message batch.
590    pub fn parse_batch(text: &str) -> serde_json::Result<Vec<Self>> {
591        // Elements stay raw so the derived impl parses each one and rejects a duplicated
592        // `event_type`; `serde_json::Value` would silently keep the last occurrence.
593        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        /// Reads only the tag, to classify a message before deserializing it.
614        #[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/// Output message type from the Polymarket WebSocket handler.
650#[derive(Debug)]
651pub enum PolymarketWsMessage {
652    Market(MarketWsMessage),
653    User(UserWsMessage),
654    /// Emitted when the underlying WebSocket reconnects.
655    ///
656    /// `shard_id` identifies the market pool shard that reconnected. Direct
657    /// clients without pool routing emit `None`.
658    Reconnected {
659        shard_id: Option<usize>,
660    },
661}
662
663/// Auth payload embedded in user-channel subscribe messages.
664#[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/// Initial market-channel subscribe request sent for a fresh WebSocket session.
673///
674/// Wire format: `{"assets_ids": [...], "type": "market", "initial_dump": true}`
675/// When `custom_feature_enabled` is true, enables new-market, market-resolved, and best-bid/ask
676/// events.
677#[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/// Incremental market-channel subscribe request sent after the initial session subscribe.
688///
689/// Wire format: `{"assets_ids": [...], "operation": "subscribe", "initial_dump": true}`
690/// When `custom_feature_enabled` is true, enables new-market, market-resolved, and best-bid/ask
691/// events.
692#[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/// Market-channel dynamic unsubscribe request sent during an active session.
702///
703/// Wire format: `{"assets_ids": [...], "operation": "unsubscribe"}`
704#[derive(Debug, Serialize)]
705pub struct MarketUnsubscribeRequest {
706    pub assets_ids: Vec<String>,
707    pub operation: &'static str,
708}
709
710/// User-channel subscribe request sent on connect.
711///
712/// Wire format: `{"auth": {...}, "type": "user"}`
713#[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    /// Repro for issue #3987: venue cancels a FOK order with a status field
911    /// containing a trailing reason ("CANCELED_<reason>") and empty fields
912    /// on `size_matched`, `outcome`, and `created_at`.
913    #[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        // Constructed from the documented required field set
1125        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    /// A duplicated `event_type` is malformed and must be rejected, matching
1286    /// [`UserWsMessage::parse`].
1287    #[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}