polyte_gamma/api/
markets.rs

1use polyte_core::{QueryBuilder, Request};
2use reqwest::Client;
3use url::Url;
4
5use crate::{error::GammaError, types::Market};
6
7/// Markets namespace for market-related operations
8#[derive(Clone)]
9pub struct Markets {
10    pub(crate) client: Client,
11    pub(crate) base_url: Url,
12}
13
14impl Markets {
15    /// Get a specific market by ID
16    pub fn get(&self, id: impl Into<String>) -> Request<Market, GammaError> {
17        Request::new(
18            self.client.clone(),
19            self.base_url.clone(),
20            format!("/markets/{}", urlencoding::encode(&id.into())),
21        )
22    }
23
24    /// Get a market by its slug
25    pub fn get_by_slug(&self, slug: impl Into<String>) -> Request<Market, GammaError> {
26        Request::new(
27            self.client.clone(),
28            self.base_url.clone(),
29            format!("/markets/slug/{}", urlencoding::encode(&slug.into())),
30        )
31    }
32
33    /// List markets with optional filtering
34    pub fn list(&self) -> ListMarkets {
35        ListMarkets {
36            request: Request::new(self.client.clone(), self.base_url.clone(), "/markets"),
37        }
38    }
39}
40
41/// Request builder for listing markets
42pub struct ListMarkets {
43    request: Request<Vec<Market>, GammaError>,
44}
45
46impl ListMarkets {
47    /// Set maximum number of results (minimum: 0)
48    pub fn limit(mut self, limit: u32) -> Self {
49        self.request = self.request.query("limit", limit);
50        self
51    }
52
53    /// Set pagination offset (minimum: 0)
54    pub fn offset(mut self, offset: u32) -> Self {
55        self.request = self.request.query("offset", offset);
56        self
57    }
58
59    /// Set order fields (comma-separated list)
60    pub fn order(mut self, order: impl Into<String>) -> Self {
61        self.request = self.request.query("order", order.into());
62        self
63    }
64
65    /// Set sort direction
66    pub fn ascending(mut self, ascending: bool) -> Self {
67        self.request = self.request.query("ascending", ascending);
68        self
69    }
70
71    /// Filter by specific market IDs
72    pub fn id(mut self, ids: impl IntoIterator<Item = i64>) -> Self {
73        self.request = self.request.query_many("id", ids);
74        self
75    }
76
77    /// Filter by market slugs
78    pub fn slug(mut self, slugs: impl IntoIterator<Item = impl ToString>) -> Self {
79        self.request = self.request.query_many("slug", slugs);
80        self
81    }
82
83    /// Filter by CLOB token IDs
84    pub fn clob_token_ids(mut self, token_ids: impl IntoIterator<Item = impl ToString>) -> Self {
85        self.request = self.request.query_many("clob_token_ids", token_ids);
86        self
87    }
88
89    /// Filter by condition IDs
90    pub fn condition_ids(mut self, condition_ids: impl IntoIterator<Item = impl ToString>) -> Self {
91        self.request = self.request.query_many("condition_ids", condition_ids);
92        self
93    }
94
95    /// Filter by market maker addresses
96    pub fn market_maker_address(
97        mut self,
98        addresses: impl IntoIterator<Item = impl ToString>,
99    ) -> Self {
100        self.request = self.request.query_many("market_maker_address", addresses);
101        self
102    }
103
104    /// Set minimum liquidity threshold
105    pub fn liquidity_num_min(mut self, min: f64) -> Self {
106        self.request = self.request.query("liquidity_num_min", min);
107        self
108    }
109
110    /// Set maximum liquidity threshold
111    pub fn liquidity_num_max(mut self, max: f64) -> Self {
112        self.request = self.request.query("liquidity_num_max", max);
113        self
114    }
115
116    /// Set minimum trading volume
117    pub fn volume_num_min(mut self, min: f64) -> Self {
118        self.request = self.request.query("volume_num_min", min);
119        self
120    }
121
122    /// Set maximum trading volume
123    pub fn volume_num_max(mut self, max: f64) -> Self {
124        self.request = self.request.query("volume_num_max", max);
125        self
126    }
127
128    /// Set earliest market start date (ISO 8601 format)
129    pub fn start_date_min(mut self, date: impl Into<String>) -> Self {
130        self.request = self.request.query("start_date_min", date.into());
131        self
132    }
133
134    /// Set latest market start date (ISO 8601 format)
135    pub fn start_date_max(mut self, date: impl Into<String>) -> Self {
136        self.request = self.request.query("start_date_max", date.into());
137        self
138    }
139
140    /// Set earliest market end date (ISO 8601 format)
141    pub fn end_date_min(mut self, date: impl Into<String>) -> Self {
142        self.request = self.request.query("end_date_min", date.into());
143        self
144    }
145
146    /// Set latest market end date (ISO 8601 format)
147    pub fn end_date_max(mut self, date: impl Into<String>) -> Self {
148        self.request = self.request.query("end_date_max", date.into());
149        self
150    }
151
152    /// Filter by tag identifier
153    pub fn tag_id(mut self, tag_id: i64) -> Self {
154        self.request = self.request.query("tag_id", tag_id);
155        self
156    }
157
158    /// Include related tags in response
159    pub fn related_tags(mut self, include: bool) -> Self {
160        self.request = self.request.query("related_tags", include);
161        self
162    }
163
164    /// Filter for create-your-own markets
165    pub fn cyom(mut self, cyom: bool) -> Self {
166        self.request = self.request.query("cyom", cyom);
167        self
168    }
169
170    /// Filter by UMA resolution status
171    pub fn uma_resolution_status(mut self, status: impl Into<String>) -> Self {
172        self.request = self.request.query("uma_resolution_status", status.into());
173        self
174    }
175
176    /// Filter by game identifier
177    pub fn game_id(mut self, game_id: impl Into<String>) -> Self {
178        self.request = self.request.query("game_id", game_id.into());
179        self
180    }
181
182    /// Filter by sports market types
183    pub fn sports_market_types(mut self, types: impl IntoIterator<Item = impl ToString>) -> Self {
184        self.request = self.request.query_many("sports_market_types", types);
185        self
186    }
187
188    /// Set minimum rewards threshold
189    pub fn rewards_min_size(mut self, min: f64) -> Self {
190        self.request = self.request.query("rewards_min_size", min);
191        self
192    }
193
194    /// Filter by question identifiers
195    pub fn question_ids(mut self, question_ids: impl IntoIterator<Item = impl ToString>) -> Self {
196        self.request = self.request.query_many("question_ids", question_ids);
197        self
198    }
199
200    /// Include tag data in results
201    pub fn include_tag(mut self, include: bool) -> Self {
202        self.request = self.request.query("include_tag", include);
203        self
204    }
205
206    /// Filter for closed or active markets
207    pub fn closed(mut self, closed: bool) -> Self {
208        self.request = self.request.query("closed", closed);
209        self
210    }
211
212    /// Filter by active status (convenience method, opposite of closed)
213    pub fn active(mut self, active: bool) -> Self {
214        self.request = self.request.query("closed", !active);
215        self
216    }
217
218    /// Filter by archived status
219    pub fn archived(mut self, archived: bool) -> Self {
220        self.request = self.request.query("archived", archived);
221        self
222    }
223
224    /// Execute the request
225    pub async fn send(self) -> crate::error::Result<Vec<Market>> {
226        self.request.send().await
227    }
228}
polyte_gamma/api/markets.rs

polyte_gamma/api/
markets.rs
