Feat/improve fee history performance

crates/net/downloaders/src/test_utils/bodies_client.rs

@@ -92,7 +92,7 @@ impl BodiesClient for TestBodiesClient {
 
         Box::pin(async move {
             if should_respond_empty {
-                return Ok((PeerId::default(), vec![]).into());
+                return Ok((PeerId::default(), vec![]).into())
             }
 
             if should_delay {

crates/net/eth-wire/src/capability.rs

@@ -252,7 +252,7 @@ impl SharedCapability {
     /// Returns an error if the offset is equal or less than [`MAX_RESERVED_MESSAGE_ID`].
     pub(crate) fn new(name: &str, version: u8, offset: u8) -> Result<Self, SharedCapabilityError> {
         if offset <= MAX_RESERVED_MESSAGE_ID {
-            return Err(SharedCapabilityError::ReservedMessageIdOffset(offset));
+            return Err(SharedCapabilityError::ReservedMessageIdOffset(offset))
         }
 
         match name {

crates/primitives/src/snapshot/segment.rs

@@ -117,15 +117,15 @@ impl SnapshotSegment {
     ) -> Option<(Self, RangeInclusive<BlockNumber>, RangeInclusive<TxNumber>)> {
         let mut parts = name.to_str()?.split('_');
         if parts.next() != Some("snapshot") {
-            return None;
+            return None
         }
 
         let segment = Self::from_str(parts.next()?).ok()?;
         let (block_start, block_end) = (parts.next()?.parse().ok()?, parts.next()?.parse().ok()?);
         let (tx_start, tx_end) = (parts.next()?.parse().ok()?, parts.next()?.parse().ok()?);
 
         if block_start >= block_end || tx_start > tx_end {
-            return None;
+            return None
         }
 
         Some((segment, block_start..=block_end, tx_start..=tx_end))

crates/rpc/rpc-builder/src/auth.rs

@@ -16,7 +16,10 @@ use reth_provider::{
     StateProviderFactory,
 };
 use reth_rpc::{
-    eth::{cache::EthStateCache, gas_oracle::GasPriceOracle, EthFilterConfig},
+    eth::{
+        cache::EthStateCache, gas_oracle::GasPriceOracle, EthFilterConfig, FeeHistoryCache,
+        FeeHistoryCacheConfig,
+    },
     AuthLayer, BlockingTaskPool, Claims, EngineEthApi, EthApi, EthFilter,
     EthSubscriptionIdProvider, JwtAuthValidator, JwtSecret,
 };
@@ -57,7 +60,11 @@ where
     // spawn a new cache task
     let eth_cache =
         EthStateCache::spawn_with(provider.clone(), Default::default(), executor.clone());
+
     let gas_oracle = GasPriceOracle::new(provider.clone(), Default::default(), eth_cache.clone());
+
+    let fee_history_cache =
+        FeeHistoryCache::new(eth_cache.clone(), FeeHistoryCacheConfig::default());
     let eth_api = EthApi::with_spawner(
         provider.clone(),
         pool.clone(),
@@ -67,6 +74,7 @@ where
         EthConfig::default().rpc_gas_cap,
         Box::new(executor.clone()),
         BlockingTaskPool::build().expect("failed to build tracing pool"),
+        fee_history_cache,
     );
     let config = EthFilterConfig::default()
         .max_logs_per_response(DEFAULT_MAX_LOGS_PER_RESPONSE)

crates/rpc/rpc-builder/src/eth.rs

@@ -5,7 +5,7 @@ use reth_rpc::{
     eth::{
         cache::{EthStateCache, EthStateCacheConfig},
         gas_oracle::GasPriceOracleConfig,
-        EthFilterConfig, RPC_DEFAULT_GAS_CAP,
+        EthFilterConfig, FeeHistoryCacheConfig, RPC_DEFAULT_GAS_CAP,
     },
     BlockingTaskPool, EthApi, EthFilter, EthPubSub,
 };
@@ -46,6 +46,8 @@ pub struct EthConfig {
     ///
     /// Sets TTL for stale filters
     pub stale_filter_ttl: std::time::Duration,
+    /// Settings for the fee history cache
+    pub fee_history_cache: FeeHistoryCacheConfig,
 }
 
 impl EthConfig {
@@ -71,6 +73,7 @@ impl Default for EthConfig {
             max_logs_per_response: DEFAULT_MAX_LOGS_PER_RESPONSE,
             rpc_gas_cap: RPC_DEFAULT_GAS_CAP.into(),
             stale_filter_ttl: DEFAULT_STALE_FILTER_TTL,
+            fee_history_cache: FeeHistoryCacheConfig::default(),
         }
     }
 }

crates/rpc/rpc-builder/src/lib.rs

@@ -168,8 +168,9 @@ use reth_provider::{
 use reth_rpc::{
     eth::{
         cache::{cache_new_blocks_task, EthStateCache},
+        fee_history_cache_new_blocks_task,
         gas_oracle::GasPriceOracle,
-        EthBundle,
+        EthBundle, FeeHistoryCache,
     },
     AdminApi, AuthLayer, BlockingTaskGuard, BlockingTaskPool, Claims, DebugApi, EngineEthApi,
     EthApi, EthFilter, EthPubSub, EthSubscriptionIdProvider, JwtAuthValidator, JwtSecret, NetApi,
@@ -1153,6 +1154,10 @@ where
     }
 
     /// Creates the [EthHandlers] type the first time this is called.
+    ///
+    /// This will spawn the required service tasks for [EthApi] for:
+    ///   - [EthStateCache]
+    ///   - [FeeHistoryCache]
     fn with_eth<F, R>(&mut self, f: F) -> R
     where
         F: FnOnce(&EthHandlers<Provider, Pool, Network, Events>) -> R,
@@ -1170,13 +1175,27 @@ where
             );
             let new_canonical_blocks = self.events.canonical_state_stream();
             let c = cache.clone();
+
             self.executor.spawn_critical(
                 "cache canonical blocks task",
                 Box::pin(async move {
                     cache_new_blocks_task(c, new_canonical_blocks).await;
                 }),
             );
 
+            let fee_history_cache =
+                FeeHistoryCache::new(cache.clone(), self.config.eth.fee_history_cache.clone());
+            let new_canonical_blocks = self.events.canonical_state_stream();
+            let fhc = fee_history_cache.clone();
+            let provider_clone = self.provider.clone();
+            self.executor.spawn_critical(
+                "cache canonical blocks for fee history task",
+                Box::pin(async move {
+                    fee_history_cache_new_blocks_task(fhc, new_canonical_blocks, provider_clone)
+                        .await;
+                }),
+            );
+
             let executor = Box::new(self.executor.clone());
             let blocking_task_pool =
                 BlockingTaskPool::build().expect("failed to build tracing pool");
@@ -1189,6 +1208,7 @@ where
                 self.config.eth.rpc_gas_cap,
                 executor.clone(),
                 blocking_task_pool.clone(),
+                fee_history_cache,
             );
             let filter = EthFilter::new(
                 self.provider.clone(),

crates/rpc/rpc-types/src/serde_helpers/json_u256.rs

@@ -162,11 +162,11 @@ where
         } else {
             // We could try to convert to a u128 here but there would probably be loss of
             // precision, so we just return an error.
-            return Err(Error::custom("Deserializing a large non-mainnet TTD is not supported"));
+            return Err(Error::custom("Deserializing a large non-mainnet TTD is not supported"))
         }
     } else {
         // must be i64 - negative numbers are not supported
-        return Err(Error::custom("Negative TTD values are invalid and will not be deserialized"));
+        return Err(Error::custom("Negative TTD values are invalid and will not be deserialized"))
     };
 
     Ok(num)