reth_rpc_eth_types/builder/
config.rs1use std::time::Duration;
4
5use crate::{
6 EthStateCacheConfig, FeeHistoryCacheConfig, ForwardConfig, GasPriceOracleConfig,
7 RPC_DEFAULT_GAS_CAP,
8};
9use reqwest::Url;
10use reth_rpc_server_types::constants::{
11 default_max_tracing_requests, DEFAULT_ETH_PROOF_WINDOW, DEFAULT_MAX_BLOCKS_PER_FILTER,
12 DEFAULT_MAX_LOGS_PER_RESPONSE, DEFAULT_MAX_SIMULATE_BLOCKS, DEFAULT_MAX_TRACE_FILTER_BLOCKS,
13 DEFAULT_PROOF_PERMITS,
14};
15use serde::{Deserialize, Serialize};
16
17pub const DEFAULT_STALE_FILTER_TTL: Duration = Duration::from_secs(5 * 60);
19
20#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Default)]
22#[serde(rename_all = "lowercase")]
23pub enum PendingBlockKind {
24 Empty,
26 None,
28 #[default]
30 Full,
31}
32
33impl std::str::FromStr for PendingBlockKind {
34 type Err = String;
35
36 fn from_str(s: &str) -> Result<Self, Self::Err> {
37 match s.to_lowercase().as_str() {
38 "empty" => Ok(Self::Empty),
39 "none" => Ok(Self::None),
40 "full" => Ok(Self::Full),
41 _ => Err(format!(
42 "Invalid pending block kind: {s}. Valid options are: empty, none, full"
43 )),
44 }
45 }
46}
47
48impl PendingBlockKind {
49 pub const fn is_none(&self) -> bool {
51 matches!(self, Self::None)
52 }
53
54 pub const fn is_empty(&self) -> bool {
56 matches!(self, Self::Empty)
57 }
58}
59
60#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
62pub struct EthConfig {
63 pub cache: EthStateCacheConfig,
65 pub gas_oracle: GasPriceOracleConfig,
67 pub eth_proof_window: u64,
69 pub max_tracing_requests: usize,
71 pub max_trace_filter_blocks: u64,
73 pub max_blocks_per_filter: u64,
75 pub max_logs_per_response: usize,
77 pub rpc_gas_cap: u64,
81 pub rpc_max_simulate_blocks: u64,
83 pub stale_filter_ttl: Duration,
86 pub fee_history_cache: FeeHistoryCacheConfig,
88 pub proof_permits: usize,
90 pub max_batch_size: usize,
92 pub pending_block_kind: PendingBlockKind,
94 pub raw_tx_forwarder: ForwardConfig,
96}
97
98impl EthConfig {
99 pub fn filter_config(&self) -> EthFilterConfig {
101 EthFilterConfig::default()
102 .max_blocks_per_filter(self.max_blocks_per_filter)
103 .max_logs_per_response(self.max_logs_per_response)
104 .stale_filter_ttl(self.stale_filter_ttl)
105 }
106}
107
108impl Default for EthConfig {
109 fn default() -> Self {
110 Self {
111 cache: EthStateCacheConfig::default(),
112 gas_oracle: GasPriceOracleConfig::default(),
113 eth_proof_window: DEFAULT_ETH_PROOF_WINDOW,
114 max_tracing_requests: default_max_tracing_requests(),
115 max_trace_filter_blocks: DEFAULT_MAX_TRACE_FILTER_BLOCKS,
116 max_blocks_per_filter: DEFAULT_MAX_BLOCKS_PER_FILTER,
117 max_logs_per_response: DEFAULT_MAX_LOGS_PER_RESPONSE,
118 rpc_gas_cap: RPC_DEFAULT_GAS_CAP.into(),
119 rpc_max_simulate_blocks: DEFAULT_MAX_SIMULATE_BLOCKS,
120 stale_filter_ttl: DEFAULT_STALE_FILTER_TTL,
121 fee_history_cache: FeeHistoryCacheConfig::default(),
122 proof_permits: DEFAULT_PROOF_PERMITS,
123 max_batch_size: 1,
124 pending_block_kind: PendingBlockKind::Full,
125 raw_tx_forwarder: ForwardConfig::default(),
126 }
127 }
128}
129
130impl EthConfig {
131 pub const fn state_cache(mut self, cache: EthStateCacheConfig) -> Self {
133 self.cache = cache;
134 self
135 }
136
137 pub const fn gpo_config(mut self, gas_oracle_config: GasPriceOracleConfig) -> Self {
139 self.gas_oracle = gas_oracle_config;
140 self
141 }
142
143 pub const fn max_tracing_requests(mut self, max_requests: usize) -> Self {
145 self.max_tracing_requests = max_requests;
146 self
147 }
148
149 pub const fn max_blocks_per_filter(mut self, max_blocks: u64) -> Self {
151 self.max_blocks_per_filter = max_blocks;
152 self
153 }
154
155 pub const fn max_trace_filter_blocks(mut self, max_blocks: u64) -> Self {
157 self.max_trace_filter_blocks = max_blocks;
158 self
159 }
160
161 pub const fn max_logs_per_response(mut self, max_logs: usize) -> Self {
163 self.max_logs_per_response = max_logs;
164 self
165 }
166
167 pub const fn rpc_gas_cap(mut self, rpc_gas_cap: u64) -> Self {
169 self.rpc_gas_cap = rpc_gas_cap;
170 self
171 }
172
173 pub const fn rpc_max_simulate_blocks(mut self, max_blocks: u64) -> Self {
175 self.rpc_max_simulate_blocks = max_blocks;
176 self
177 }
178
179 pub const fn eth_proof_window(mut self, window: u64) -> Self {
181 self.eth_proof_window = window;
182 self
183 }
184
185 pub const fn proof_permits(mut self, permits: usize) -> Self {
187 self.proof_permits = permits;
188 self
189 }
190
191 pub const fn max_batch_size(mut self, max_batch_size: usize) -> Self {
193 self.max_batch_size = max_batch_size;
194 self
195 }
196
197 pub const fn pending_block_kind(mut self, pending_block_kind: PendingBlockKind) -> Self {
199 self.pending_block_kind = pending_block_kind;
200 self
201 }
202
203 pub fn raw_tx_forwarder(mut self, tx_forwarder: Option<Url>) -> Self {
205 if let Some(tx_forwarder) = tx_forwarder {
206 self.raw_tx_forwarder.tx_forwarder = Some(tx_forwarder);
207 }
208 self
209 }
210}
211
212#[derive(Debug, Clone, PartialEq, Eq)]
214pub struct EthFilterConfig {
215 pub max_blocks_per_filter: Option<u64>,
219 pub max_logs_per_response: Option<usize>,
223 pub stale_filter_ttl: Duration,
228}
229
230impl EthFilterConfig {
231 pub const fn max_blocks_per_filter(mut self, num: u64) -> Self {
233 self.max_blocks_per_filter = Some(num);
234 self
235 }
236
237 pub const fn max_logs_per_response(mut self, num: usize) -> Self {
240 self.max_logs_per_response = Some(num);
241 self
242 }
243
244 pub const fn stale_filter_ttl(mut self, duration: Duration) -> Self {
246 self.stale_filter_ttl = duration;
247 self
248 }
249}
250
251impl Default for EthFilterConfig {
252 fn default() -> Self {
253 Self {
254 max_blocks_per_filter: None,
255 max_logs_per_response: None,
256 stale_filter_ttl: Duration::from_secs(5 * 60),
258 }
259 }
260}