1use serde::{Deserialize, Serialize};
2use std::vec;
3
4#[derive(Debug, Serialize, Deserialize)]
5pub struct APIResponse<T> {
6 pub status: String,
7 pub message: String,
8 pub data: T,
9}
10
11#[derive(Debug, Serialize, Deserialize)]
12pub struct WalletAggregatedPnL {
13 #[serde(rename = "investedAmount")]
14 pub invested_amount: f64,
15 #[serde(rename = "pnlPercent")]
16 pub pnl_percent: f64,
17 #[serde(rename = "pnlUsd")]
18 pub pnl_usd: f64,
19 #[serde(rename = "soldAmount")]
20 pub sold_amount: f64,
21 #[serde(rename = "tokensTraded")]
22 pub tokens_traded: i32,
23 #[serde(rename = "totalPnlPercent")]
24 pub total_pnl_percent: f64,
25 #[serde(rename = "totalPnlUsd")]
26 pub total_pnl_usd: f64,
27 #[serde(rename = "unrealizedPnlPercent")]
28 pub unrealized_pnl_percent: f64,
29 #[serde(rename = "unrealizedPnlUsd")]
30 pub unrealized_pnl_usd: f64,
31}
32
33#[derive(Debug, Serialize, Deserialize)]
34pub struct WalletHolding {
35 #[serde(rename = "marketId")]
36 pub market_id: String,
37 #[serde(rename = "tokenHoldings")]
38 pub token_holdings: f64,
39 #[serde(rename = "tokenSymbol")]
40 pub token_symbol: String,
41 #[serde(rename = "usdValue")]
42 pub usd_value: f64,
43}
44
45#[derive(Debug, Serialize, Deserialize)]
46pub struct WalletPnL {
47 #[serde(rename = "holderSince")]
48 pub holder_since: i64,
49 #[serde(rename = "investedAmount")]
50 pub invested_amount: f64,
51 #[serde(rename = "investedTxns")]
52 pub invested_txns: i32,
53 #[serde(rename = "pnlPercent")]
54 pub pnl_percent: f64,
55 #[serde(rename = "pnlUsd")]
56 pub pnl_usd: f64,
57 #[serde(rename = "remainingTokens")]
58 pub remaining_tokens: f64,
59 #[serde(rename = "remainingUsd")]
60 pub remaining_usd: f64,
61 #[serde(rename = "soldAmount")]
62 pub sold_amount: f64,
63 #[serde(rename = "soldTxns")]
64 pub sold_txns: i32,
65}
66
67#[derive(Debug, Serialize, Deserialize)]
68pub struct TopTrader {
69 #[serde(rename = "investedAmount_tokens")]
70 pub invested_amount_tokens: f64,
71 #[serde(rename = "investedAmount_usd")]
72 pub invested_amount_usd: f64,
73 #[serde(rename = "investedTxns")]
74 pub invested_txns: i32,
75 #[serde(rename = "pnlUsd")]
76 pub pnl_usd: f64,
77 #[serde(rename = "remainingTokens")]
78 pub remaining_tokens: f64,
79 #[serde(rename = "remainingUsd")]
80 pub remaining_usd: f64,
81 #[serde(rename = "soldAmountTokens")]
82 pub sold_amount_tokens: f64,
83 #[serde(rename = "soldAmountUsd")]
84 pub sold_amount_usd: f64,
85 #[serde(rename = "soldTxns")]
86 pub sold_txns: i32,
87 #[serde(rename = "walletAddress")]
88 pub wallet_address: String,
89 #[serde(rename = "walletTag")]
90 pub wallet_tag: Option<String>,
91}
92
93#[derive(Debug, Serialize, Deserialize)]
94pub struct TokenSearchResult {
95 #[serde(rename = "chainId")]
96 pub chain_id: i32,
97 #[serde(rename = "marketId")]
98 pub market_id: String,
99 #[serde(rename = "createdTimestamp")]
100 pub created_timestamp: i64,
101 pub name: String,
102 pub symbol: String,
103 #[serde(rename = "tokenMint")]
104 pub token_mint: String,
105 #[serde(rename = "tokenType")]
106 pub token_type: String,
107 #[serde(rename = "percentChange24h")]
108 pub percent_change_24h: f64,
109 #[serde(rename = "pooledAsset")]
110 pub pooled_asset: f64,
111 #[serde(rename = "tokenLiquidityUsd")]
112 pub token_liquidity_usd: f64,
113 #[serde(rename = "tokenMarketCapUsd")]
114 pub token_market_cap_usd: f64,
115 #[serde(rename = "tokenPriceUsd")]
116 pub token_price_usd: f64,
117 #[serde(rename = "volumeUsd")]
118 pub volume_usd: f64,
119 pub image: Option<String>,
120 pub telegram: Option<String>,
121 pub twitter: Option<String>,
122 pub website: Option<String>,
123}
124
125#[derive(Debug, Serialize, Deserialize)]
126pub struct TokenMarket {
127 #[serde(rename = "marketCapUsd")]
128 pub market_cap_usd: f64,
129 #[serde(rename = "marketID")]
130 pub market_id: String,
131 #[serde(rename = "tokenLiquidityUsd")]
132 pub token_liquidity_usd: f64,
133 #[serde(rename = "tokenType")]
134 pub token_type: String,
135}
136
137#[derive(Debug, Serialize, Deserialize)]
138pub struct TokenMetadata {
139 pub image: Option<String>,
140 pub name: String,
141 pub symbol: String,
142 pub telegram: Option<String>,
143 pub twitter: Option<String>,
144 pub website: Option<String>,
145}
146
147#[derive(Debug, Serialize, Deserialize)]
148pub struct TokenSymbol {
149 pub symbol: String,
150}
151
152#[derive(Debug, Serialize, Deserialize)]
153pub struct TokenHolder {
154 #[serde(rename = "percentOwned")]
155 pub percent_owned: f64,
156 #[serde(rename = "tokenHoldings")]
157 pub token_holdings: f64,
158 #[serde(rename = "usdHoldings")]
159 pub usd_holdings: f64,
160 #[serde(rename = "walletAddress")]
161 pub wallet_address: String,
162 #[serde(rename = "walletTag")]
163 pub wallet_tag: Option<String>,
164}
165
166#[derive(Debug, Serialize, Deserialize)]
167pub struct TokenATH {
168 #[serde(rename = "marketCapUsd")]
169 pub market_cap_usd: f64,
170 pub timestamp: i64,
171 #[serde(rename = "tokenLiquidityUsd")]
172 pub token_liquidity_usd: f64,
173}
174
175#[derive(Debug, Serialize, Deserialize)]
176pub struct MigrationState {
177 #[serde(rename = "durationMinutes")]
178 pub duration_minutes: i32,
179 pub makers: i32,
180 #[serde(rename = "migrationTimestamp")]
181 pub migration_timestamp: i64,
182 pub volume: f64,
183}
184
185#[derive(Debug, Serialize, Deserialize)]
186pub struct TokenPair {
187 pub abused: Option<bool>,
188 #[serde(rename = "bondingCurvePercentage")]
189 pub bonding_curve_percentage: Option<f64>,
190 #[serde(rename = "buyTxnCount")]
191 pub buy_txn_count: i32,
192 #[serde(rename = "chainId")]
193 pub chain_id: i32,
194 #[serde(rename = "contractCreator")]
195 pub contract_creator: String,
196 #[serde(rename = "createdTimestamp")]
197 pub created_timestamp: i64,
198 pub description: Option<String>,
199 #[serde(rename = "freezeAuthority")]
200 pub freeze_authority: Option<bool>,
201 pub image: Option<String>,
202 #[serde(rename = "initialAssetLiquidity")]
203 pub initial_asset_liquidity: f64,
204 #[serde(rename = "initialUsdLiquidity")]
205 pub initial_usd_liquidity: f64,
206 #[serde(rename = "isMigrated")]
207 pub is_migrated: Option<bool>,
208 #[serde(rename = "lpBurned")]
209 pub lp_burned: bool,
210 #[serde(rename = "lpCreator")]
211 pub lp_creator: String,
212 #[serde(rename = "marketId")]
213 pub market_id: String,
214 #[serde(rename = "metadataUri")]
215 pub metadata_uri: Option<String>,
216 #[serde(rename = "migratedMarketId")]
217 pub migrated_market_id: Option<String>,
218 #[serde(rename = "migrationState")]
219 pub migration_state: Option<MigrationState>,
220 #[serde(rename = "mintAuthority")]
221 pub mint_authority: Option<bool>,
222 pub name: String,
223 #[serde(rename = "pooledAsset")]
224 pub pooled_asset: f64,
225 #[serde(rename = "pooledToken")]
226 pub pooled_token: f64,
227 #[serde(rename = "priceChangePercent")]
228 pub price_change_percent: f64,
229 #[serde(rename = "sellTxnCount")]
230 pub sell_txn_count: i32,
231 pub symbol: String,
232 pub telegram: Option<String>,
233 #[serde(rename = "tokenLiquidityAsset")]
234 pub token_liquidity_asset: f64,
235 #[serde(rename = "tokenLiquidityUsd")]
236 pub token_liquidity_usd: f64,
237 #[serde(rename = "tokenMarketCapAsset")]
238 pub token_market_cap_asset: f64,
239 #[serde(rename = "tokenMarketCapUsd")]
240 pub token_market_cap_usd: f64,
241 #[serde(rename = "tokenMint")]
242 pub token_mint: String,
243 #[serde(rename = "tokenPriceAsset")]
244 pub token_price_asset: f64,
245 #[serde(rename = "tokenPriceUsd")]
246 pub token_price_usd: f64,
247 #[serde(rename = "tokenType")]
248 pub token_type: String,
249 #[serde(rename = "top10HoldingPercent")]
250 pub top10_holding_percent: f64,
251 #[serde(rename = "totalSupply")]
252 pub total_supply: f64,
253 #[serde(rename = "transactionCount")]
254 pub transaction_count: i32,
255 pub twitter: Option<String>,
256 #[serde(rename = "volumeAsset")]
257 pub volume_asset: f64,
258 #[serde(rename = "volumeUsd")]
259 pub volume_usd: f64,
260 pub website: Option<String>,
261}
262
263#[derive(Debug, Serialize, Deserialize)]
264pub struct TokenPairs {
265 #[serde(rename = "hasNext")]
266 pub has_next: bool,
267 pub pairs: Vec<TokenPair>,
268}
269
270#[derive(Debug, Serialize, Deserialize)]
271pub struct ChainAction {
272 pub signer: String,
273 #[serde(rename = "tokenAccount")]
274 pub token_account: Option<String>,
275 #[serde(rename = "transactionId")]
276 pub transaction_id: String,
277 #[serde(rename = "tokenMint")]
278 pub token_mint: Option<String>,
279 #[serde(rename = "marketId")]
280 pub market_id: String,
281 #[serde(rename = "actionType")]
282 pub action_type: String,
283 #[serde(rename = "tokenAmount")]
284 pub token_amount: f64,
285 #[serde(rename = "assetAmount")]
286 pub asset_amount: f64,
287 #[serde(rename = "tokenPriceUsd")]
288 pub token_price_usd: f64,
289 #[serde(rename = "tokenPriceAsset")]
290 pub token_price_asset: f64,
291 #[serde(rename = "swapTotalUsd")]
292 pub swap_total_usd: Option<f64>,
293 #[serde(rename = "swapTotalAsset")]
294 pub swap_total_asset: Option<f64>,
295 #[serde(rename = "tokenMarketCapAsset")]
296 pub token_market_cap_asset: f64,
297 #[serde(rename = "tokenMarketCapUsd")]
298 pub token_market_cap_usd: f64,
299 #[serde(rename = "tokenLiquidityAsset")]
300 pub token_liquidity_asset: f64,
301 #[serde(rename = "tokenLiquidityUsd")]
302 pub token_liquidity_usd: f64,
303 #[serde(rename = "pooledToken")]
304 pub pooled_token: f64,
305 #[serde(rename = "pooledAsset")]
306 pub pooled_asset: f64,
307 #[serde(rename = "actionTimestamp")]
308 pub action_timestamp: i64,
309 #[serde(rename = "bondingCurvePercentage")]
310 pub bonding_curve_percentage: Option<f64>,
311 #[serde(rename = "botUsed")]
312 pub bot_used: Option<String>,
313}
314
315#[derive(Debug, Serialize, Deserialize)]
316pub struct TokenPairsParams {
317 #[serde(rename = "atLeastOneSocial")]
318 pub at_least_one_social: Option<bool>,
319 #[serde(rename = "buysMax")]
320 pub buys_max: Option<i32>,
321 #[serde(rename = "buysMin")]
322 pub buys_min: Option<i32>,
323 #[serde(rename = "chainIds")]
324 pub chain_ids: Option<Vec<i32>>,
325 #[serde(rename = "freezeAuthDisabled")]
326 pub freeze_auth_disabled: Option<bool>,
327 #[serde(rename = "initialLiquidityMax")]
328 pub initial_liquidity_max: Option<f64>,
329 #[serde(rename = "initialLiquidityMin")]
330 pub initial_liquidity_min: Option<f64>,
331 pub interval: Option<String>,
332 #[serde(rename = "liquidityMax")]
333 pub liquidity_max: Option<f64>,
334 #[serde(rename = "liquidityMin")]
335 pub liquidity_min: Option<f64>,
336 #[serde(rename = "lpBurned")]
337 pub lp_burned: Option<bool>,
338 #[serde(rename = "marketCapMax")]
339 pub market_cap_max: Option<f64>,
340 #[serde(rename = "marketCapMin")]
341 pub market_cap_min: Option<f64>,
342 #[serde(rename = "mintAuthDisabled")]
343 pub mint_auth_disabled: Option<bool>,
344 pub page: Option<i32>,
345 #[serde(rename = "sellsMax")]
346 pub sells_max: Option<i32>,
347 #[serde(rename = "sellsMin")]
348 pub sells_min: Option<i32>,
349 pub sorting: Option<String>,
350 #[serde(rename = "swapsMax")]
351 pub swaps_max: Option<i32>,
352 #[serde(rename = "swapsMin")]
353 pub swaps_min: Option<i32>,
354 #[serde(rename = "tokenTypes")]
355 pub token_types: Option<Vec<String>>,
356 #[serde(rename = "top10Holders")]
357 pub top10_holders: Option<bool>,
358 #[serde(rename = "volumeMax")]
359 pub volume_max: Option<f64>,
360 #[serde(rename = "volumeMin")]
361 pub volume_min: Option<f64>,
362}
363
364impl IntoIterator for TokenPairsParams {
365 type Item = (&'static str, String);
366 type IntoIter = vec::IntoIter<Self::Item>;
367
368 fn into_iter(self) -> Self::IntoIter {
369 let mut params = Vec::new();
370
371 if let Some(v) = self.at_least_one_social {
372 params.push(("atLeastOneSocial", v.to_string()));
373 }
374 if let Some(v) = self.buys_max {
375 params.push(("buysMax", v.to_string()));
376 }
377 if let Some(v) = self.buys_min {
378 params.push(("buysMin", v.to_string()));
379 }
380 if let Some(v) = self.chain_ids {
381 params.push(("chainIds", v.iter().map(|id| id.to_string()).collect::<Vec<_>>().join(",")));
382 }
383 if let Some(v) = self.freeze_auth_disabled {
384 params.push(("freezeAuthDisabled", v.to_string()));
385 }
386 if let Some(v) = self.initial_liquidity_max {
387 params.push(("initialLiquidityMax", v.to_string()));
388 }
389 if let Some(v) = self.initial_liquidity_min {
390 params.push(("initialLiquidityMin", v.to_string()));
391 }
392 if let Some(v) = self.interval {
393 params.push(("interval", v));
394 }
395 if let Some(v) = self.liquidity_max {
396 params.push(("liquidityMax", v.to_string()));
397 }
398 if let Some(v) = self.liquidity_min {
399 params.push(("liquidityMin", v.to_string()));
400 }
401 if let Some(v) = self.lp_burned {
402 params.push(("lpBurned", v.to_string()));
403 }
404 if let Some(v) = self.market_cap_max {
405 params.push(("marketCapMax", v.to_string()));
406 }
407 if let Some(v) = self.market_cap_min {
408 params.push(("marketCapMin", v.to_string()));
409 }
410 if let Some(v) = self.mint_auth_disabled {
411 params.push(("mintAuthDisabled", v.to_string()));
412 }
413 if let Some(v) = self.page {
414 params.push(("page", v.to_string()));
415 }
416 if let Some(v) = self.sells_max {
417 params.push(("sellsMax", v.to_string()));
418 }
419 if let Some(v) = self.sells_min {
420 params.push(("sellsMin", v.to_string()));
421 }
422 if let Some(v) = self.sorting {
423 params.push(("sorting", v));
424 }
425 if let Some(v) = self.swaps_max {
426 params.push(("swapsMax", v.to_string()));
427 }
428 if let Some(v) = self.swaps_min {
429 params.push(("swapsMin", v.to_string()));
430 }
431 if let Some(v) = self.token_types {
432 params.push(("tokenTypes", v.join(",")));
433 }
434 if let Some(v) = self.top10_holders {
435 params.push(("top10Holders", v.to_string()));
436 }
437 if let Some(v) = self.volume_max {
438 params.push(("volumeMax", v.to_string()));
439 }
440 if let Some(v) = self.volume_min {
441 params.push(("volumeMin", v.to_string()));
442 }
443
444 params.into_iter()
445 }
446}
447
448impl Default for TokenPairsParams {
449 fn default() -> Self {
450 TokenPairsParams {
451 at_least_one_social: None,
452 buys_max: None,
453 buys_min: None,
454 chain_ids: None,
455 freeze_auth_disabled: None,
456 initial_liquidity_max: None,
457 initial_liquidity_min: None,
458 interval: None,
459 liquidity_max: None,
460 liquidity_min: None,
461 lp_burned: None,
462 market_cap_max: None,
463 market_cap_min: None,
464 mint_auth_disabled: None,
465 page: None,
466 sells_max: None,
467 sells_min: None,
468 sorting: None,
469 swaps_max: None,
470 swaps_min: None,
471 token_types: None,
472 top10_holders: None,
473 volume_max: None,
474 volume_min: None,
475 }
476 }
477}