helix/crates/common/src/api/data_api.rs at f47976ba723113bcb55ae8c05422eb04c2beb584 · gattaca-com/helix · GitHub

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
132
use ethereum_consensus::{
    primitives::{BlsPublicKey, ExecutionAddress, Hash32, U256},
    serde::as_str,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, PartialEq, Eq, Deserialize, Serialize, Clone)]
pub enum BidsOrderBy {
    HighToLow,
    LowToHigh,
}

#[derive(Debug, Deserialize, Serialize, Default, Clone)]
pub struct BidFilters {
    pub slot: Option<u64>,
    pub cursor: Option<u64>,
    pub limit: Option<u64>,
    pub block_hash: Option<Hash32>,
    pub block_number: Option<u64>,
    pub proposer_pubkey: Option<BlsPublicKey>,
    pub builder_pubkey: Option<BlsPublicKey>,
    pub order_by: Option<BidsOrderBy>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct ProposerPayloadDeliveredParams {
    pub slot: Option<u64>,
    pub cursor: Option<u64>,
    pub limit: Option<u64>,
    pub block_hash: Option<Hash32>,
    pub block_number: Option<u64>,
    pub proposer_pubkey: Option<BlsPublicKey>,
    pub builder_pubkey: Option<BlsPublicKey>,
    pub order_by: Option<String>,
}

impl From<ProposerPayloadDeliveredParams> for BidFilters {
    fn from(value: ProposerPayloadDeliveredParams) -> Self {
        BidFilters {
            slot: value.slot,
            cursor: value.cursor,
            limit: value.limit,
            block_hash: value.block_hash,
            block_number: value.block_number,
            proposer_pubkey: value.proposer_pubkey,
            builder_pubkey: value.builder_pubkey,
            order_by: match value.order_by.as_ref() {
                Some(s) => match s.as_str() {
                    "value" => Some(BidsOrderBy::LowToHigh),
                    "-value" => Some(BidsOrderBy::HighToLow),
                    _ => None,
                },
                None => None,
            },
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeliveredPayloadsResponse {
    #[serde(with = "as_str")]
    pub slot: u64,
    pub parent_hash: Hash32,
    pub block_hash: Hash32,
    pub builder_pubkey: BlsPublicKey,
    pub proposer_pubkey: BlsPublicKey,
    pub proposer_fee_recipient: ExecutionAddress,
    #[serde(with = "as_str")]
    pub gas_limit: u64,
    #[serde(with = "as_str")]
    pub gas_used: u64,
    #[serde(with = "as_str")]
    pub value: U256,
    #[serde(with = "as_str")]
    pub block_number: u64,
    #[serde(with = "as_str")]
    pub num_tx: usize,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct BuilderBlocksReceivedParams {
    pub slot: Option<u64>,
    pub block_hash: Option<Hash32>,
    pub block_number: Option<u64>,
    pub builder_pubkey: Option<BlsPublicKey>,
    pub limit: Option<u64>,
}

impl From<BuilderBlocksReceivedParams> for BidFilters {
    fn from(value: BuilderBlocksReceivedParams) -> Self {
        BidFilters {
            slot: value.slot,
            cursor: None,
            limit: value.limit,
            block_hash: value.block_hash,
            block_number: value.block_number,
            proposer_pubkey: None,
            builder_pubkey: value.builder_pubkey,
            order_by: None,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReceivedBlocksResponse {
    #[serde(with = "as_str")]
    pub slot: u64,
    pub parent_hash: Hash32,
    pub block_hash: Hash32,
    pub builder_pubkey: BlsPublicKey,
    pub proposer_pubkey: BlsPublicKey,
    pub proposer_fee_recipient: ExecutionAddress,
    #[serde(with = "as_str")]
    pub gas_limit: u64,
    #[serde(with = "as_str")]
    pub gas_used: u64,
    #[serde(with = "as_str")]
    pub value: U256,
    #[serde(with = "as_str")]
    pub block_number: u64,
    #[serde(with = "as_str")]
    pub num_tx: usize,
    #[serde(with = "as_str")]
    pub timestamp: u64,
    #[serde(with = "as_str")]
    pub timestamp_ms: u64,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct ValidatorRegistrationParams {
    pub pubkey: BlsPublicKey,
}