polynode 0.13.8

Rust SDK for the PolyNode API — real-time Polymarket data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Subscription builder and types.

use serde::Serialize;

/// WebSocket subscription type presets.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SubscriptionType {
    Settlements,
    Trades,
    Prices,
    Blocks,
    Wallets,
    Markets,
    LargeTrades,
    Global,
    Oracle,
    Chainlink,
}

/// Builder for creating a subscription with filters.
#[derive(Debug, Clone)]
pub struct Subscription {
    pub(crate) sub_type: SubscriptionType,
    pub(crate) filters: SubscriptionFilters,
}

#[derive(Debug, Clone, Default, Serialize)]
pub struct SubscriptionFilters {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wallets: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tokens: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slugs: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub condition_ids: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub side: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_types: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub snapshot_count: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub feeds: Option<Vec<String>>,
}

impl Subscription {
    pub fn new(sub_type: SubscriptionType) -> Self {
        Self {
            sub_type,
            filters: SubscriptionFilters::default(),
        }
    }

    pub fn wallets(mut self, wallets: Vec<String>) -> Self {
        self.filters.wallets = Some(wallets);
        self
    }

    pub fn tokens(mut self, tokens: Vec<String>) -> Self {
        self.filters.tokens = Some(tokens);
        self
    }

    pub fn slugs(mut self, slugs: Vec<String>) -> Self {
        self.filters.slugs = Some(slugs);
        self
    }

    pub fn condition_ids(mut self, ids: Vec<String>) -> Self {
        self.filters.condition_ids = Some(ids);
        self
    }

    pub fn side(mut self, side: &str) -> Self {
        self.filters.side = Some(side.to_string());
        self
    }

    pub fn status(mut self, status: &str) -> Self {
        self.filters.status = Some(status.to_string());
        self
    }

    pub fn min_size(mut self, size: f64) -> Self {
        self.filters.min_size = Some(size);
        self
    }

    pub fn max_size(mut self, size: f64) -> Self {
        self.filters.max_size = Some(size);
        self
    }

    pub fn event_types(mut self, types: Vec<String>) -> Self {
        self.filters.event_types = Some(types);
        self
    }

    pub fn snapshot_count(mut self, count: u64) -> Self {
        self.filters.snapshot_count = Some(count);
        self
    }

    pub fn feeds(mut self, feeds: Vec<String>) -> Self {
        self.filters.feeds = Some(feeds);
        self
    }

    /// Serialize to the JSON message format expected by the server.
    pub(crate) fn to_message(&self) -> serde_json::Value {
        let mut msg = serde_json::json!({
            "action": "subscribe",
            "type": self.sub_type,
        });
        let filters = serde_json::to_value(&self.filters).unwrap_or_default();
        if let serde_json::Value::Object(ref m) = filters {
            if !m.is_empty() {
                msg["filters"] = filters;
            }
        }
        msg
    }
}