1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
6pub struct StakerRewardsResponse {
7 pub rewards: Vec<StakerReward>,
8 pub total: Option<u64>,
9}
10
11#[derive(Debug, Clone, Serialize, Deserialize)]
13pub struct StakerReward {
14 pub stake_account: String,
16
17 pub stake_authority: String,
19
20 pub withdraw_authority: String,
22
23 pub epoch: u64,
25
26 pub mev_rewards: u64,
28
29 pub priority_fee_rewards: Option<u64>,
31
32 pub mev_claimed: bool,
34
35 pub priority_fee_claimed: Option<bool>,
37
38 pub vote_account: String,
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44pub struct ValidatorRewardsResponse {
45 pub validators: Vec<ValidatorReward>,
46}
47
48#[derive(Debug, Clone, Serialize, Deserialize)]
50pub struct ValidatorReward {
51 pub vote_account: String,
53
54 pub epoch: u64,
56
57 pub mev_commission_bps: u16,
59
60 pub mev_rewards: u64,
62
63 pub priority_fee_commission_bps: Option<u16>,
65
66 pub priority_fee_rewards: Option<u64>,
68
69 pub num_stakers: Option<u64>,
71
72 pub active_stake: Option<u64>,
74}
75
76#[derive(Debug, Clone, Serialize, Deserialize)]
78pub struct ValidatorsResponse {
79 pub validators: Vec<ValidatorInfo>,
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84pub struct ValidatorInfo {
85 pub vote_account: String,
87
88 pub mev_commission_bps: Option<u16>,
90
91 pub mev_rewards: Option<u64>,
93
94 pub priority_fee_commission_bps: Option<u16>,
96
97 pub priority_fee_rewards: Option<u64>,
99
100 pub running_jito: bool,
102
103 pub running_bam: Option<bool>,
105
106 pub active_stake: u64,
108}
109
110#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct ValidatorByVoteAccount {
113 pub epoch: u64,
115
116 pub mev_commission_bps: u16,
118
119 pub mev_rewards: u64,
121
122 pub priority_fee_commission_bps: u16,
124
125 pub priority_fee_rewards: u64,
127}
128
129#[derive(Debug, Clone, Serialize, Deserialize)]
131pub struct MevRewards {
132 pub epoch: u64,
134
135 pub total_network_mev_lamports: u64,
137
138 pub jito_stake_weight_lamports: u64,
140
141 pub mev_reward_per_lamport: f64,
143}
144
145#[derive(Debug, Clone, Serialize, Deserialize)]
147pub struct DailyMevRewards {
148 pub day: DateTime<Utc>,
150
151 pub count_mev_tips: u64,
153
154 pub jito_tips: f64,
156
157 pub tippers: u64,
159
160 pub validator_tips: f64,
162}
163
164#[derive(Debug, Clone, Serialize, Deserialize)]
166pub struct JitoStakeOverTime {
167 pub stake_ratio_over_time: std::collections::HashMap<String, f64>,
169}
170
171#[derive(Debug, Clone, Serialize, Deserialize)]
173pub struct MevCommissionAverageOverTime {
174 pub aggregated_mev_rewards: u64,
176
177 pub mev_rewards: Vec<TimeSeriesData<u64>>,
179
180 pub tvl: Vec<TimeSeriesData<u64>>,
182
183 pub apy: Vec<TimeSeriesData<f64>>,
185
186 pub num_validators: Vec<TimeSeriesData<u64>>,
188
189 pub supply: Vec<TimeSeriesData<f64>>,
191}
192
193#[derive(Debug, Clone, Serialize, Deserialize)]
195pub struct TimeSeriesData<T> {
196 pub data: T,
198
199 pub date: DateTime<Utc>,
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize)]
205pub struct JitoSolRatio {
206 pub ratios: Vec<TimeSeriesData<f64>>,
208}
209
210#[derive(Debug, Clone, Serialize, Deserialize)]
212pub struct StakePoolStats {
213 pub epoch: u64,
215
216 pub total_lamports: u64,
218
219 pub jitosol_supply: f64,
221
222 pub exchange_ratio: f64,
224
225 pub apy: f64,
227
228 pub num_validators: u64,
230
231 pub total_mev_earned: u64,
233}
234
235#[derive(Debug, Clone, Serialize, Deserialize)]
241pub struct EpochRequest {
242 pub epoch: u64,
244}
245
246#[derive(Debug, Clone, Serialize, Deserialize)]
248pub struct RangeFilter {
249 pub start: DateTime<Utc>,
251
252 pub end: DateTime<Utc>,
254}
255
256#[derive(Debug, Clone, Serialize, Deserialize)]
258pub struct RangeRequest {
259 pub range_filter: RangeFilter,
261}
262
263#[derive(Debug, Clone, Serialize, Deserialize)]
269pub struct ValidatorHistoryAccount {
270 pub vote_account: String,
272
273 pub history: Vec<ValidatorHistoryEntry>,
275}
276
277#[derive(Debug, Clone, Serialize, Deserialize)]
279pub struct ValidatorHistoryEntry {
280 pub epoch: u64,
282
283 pub vote_credits: Option<u32>,
285
286 pub commission: Option<u8>,
288
289 pub mev_commission_bps: Option<u16>,
291
292 pub version: Option<String>,
294
295 pub client_type: Option<String>,
297
298 pub active_stake: Option<u64>,
300
301 pub stake_rank: Option<u32>,
303
304 pub is_superminority: Option<bool>,
306
307 pub ip_address: Option<String>,
309}
310
311#[derive(Debug, Clone, Serialize, Deserialize)]
313pub struct StewardConfig {
314 pub stake_pool: String,
316
317 pub authority: String,
319
320 pub scoring_params: ScoringParams,
322}
323
324#[derive(Debug, Clone, Serialize, Deserialize)]
326pub struct ScoringParams {
327 pub min_vote_credits: u32,
329
330 pub max_commission: u8,
332
333 pub performance_weight: f64,
335
336 pub commission_weight: f64,
338
339 pub stake_concentration_limit: f64,
341}
342
343#[derive(Debug, Clone, Default)]
349pub struct QueryParams {
350 pub limit: Option<u32>,
352
353 pub offset: Option<u32>,
355
356 pub epoch: Option<u64>,
358
359 pub sort_order: Option<String>,
361}
362
363impl QueryParams {
364 pub fn with_limit(limit: u32) -> Self {
366 Self {
367 limit: Some(limit),
368 ..Default::default()
369 }
370 }
371
372 pub fn with_epoch(epoch: u64) -> Self {
374 Self {
375 epoch: Some(epoch),
376 ..Default::default()
377 }
378 }
379
380 pub fn limit(mut self, limit: u32) -> Self {
382 self.limit = Some(limit);
383 self
384 }
385
386 pub fn offset(mut self, offset: u32) -> Self {
388 self.offset = Some(offset);
389 self
390 }
391
392 pub fn epoch(mut self, epoch: u64) -> Self {
394 self.epoch = Some(epoch);
395 self
396 }
397
398 pub fn to_query_string(&self) -> String {
400 let mut params = Vec::new();
401
402 if let Some(limit) = self.limit {
403 params.push(format!("limit={}", limit));
404 }
405 if let Some(offset) = self.offset {
406 params.push(format!("offset={}", offset));
407 }
408 if let Some(epoch) = self.epoch {
409 params.push(format!("epoch={}", epoch));
410 }
411 if let Some(ref sort_order) = self.sort_order {
412 params.push(format!("sort_order={}", sort_order));
413 }
414
415 if params.is_empty() {
416 String::new()
417 } else {
418 format!("?{}", params.join("&"))
419 }
420 }
421}
422
423#[derive(Debug, Clone, Serialize, Deserialize)]
429pub struct ApiErrorResponse {
430 pub error: String,
431 pub message: Option<String>,
432 pub status_code: Option<u16>,
433}