feat: centralize base fee calculations with Prague1 support

crates/chainspec/src/api.rs

@@ -1,8 +1,8 @@
 use crate::{ChainSpec, DepositContract};
 use alloc::{boxed::Box, vec::Vec};
 use alloy_chains::Chain;
-use alloy_consensus::Header;
-use alloy_eips::{eip1559::BaseFeeParams, eip7840::BlobParams};
+use alloy_consensus::{BlockHeader, Header};
+use alloy_eips::{calc_next_block_base_fee, eip1559::BaseFeeParams, eip7840::BlobParams};
 use alloy_genesis::Genesis;
 use alloy_primitives::{B256, U256};
 use core::fmt::{Debug, Display};
@@ -65,6 +65,20 @@ pub trait EthChainSpec: Send + Sync + Unpin + Debug {
 
     /// Returns the final total difficulty if the Paris hardfork is known.
     fn final_paris_total_difficulty(&self) -> Option<U256>;
+
+    /// See [`calc_next_block_base_fee`].
+    fn next_block_base_fee<H>(&self, parent: &H, target_timestamp: u64) -> Option<u64>
+    where
+        Self: Sized,
+        H: BlockHeader,
+    {
+        Some(calc_next_block_base_fee(
+            parent.gas_used(),
+            parent.gas_limit(),
+            parent.base_fee_per_gas()?,
+            self.base_fee_params_at_timestamp(target_timestamp),
+        ))
+    }
 }
 
 impl EthChainSpec for ChainSpec {

crates/chainspec/src/lib.rs

@@ -145,4 +145,34 @@ mod tests {
         let chain: Chain = NamedChain::Holesky.into();
         assert_eq!(s, chain.public_dns_network_protocol().unwrap().as_str());
     }
+
+    #[test]
+    fn test_centralized_base_fee_calculation() {
+        use crate::{ChainSpec, EthChainSpec};
+        use alloy_consensus::Header;
+        use alloy_eips::eip1559::INITIAL_BASE_FEE;
+
+        fn parent_header() -> Header {
+            Header {
+                gas_used: 15_000_000,
+                gas_limit: 30_000_000,
+                base_fee_per_gas: Some(INITIAL_BASE_FEE),
+                timestamp: 1_000,
+                ..Default::default()
+            }
+        }
+
+        let spec = ChainSpec::default();
+        let parent = parent_header();
+
+        // For testing, assume next block has timestamp 12 seconds later
+        let next_timestamp = parent.timestamp + 12;
+
+        let expected = parent
+            .next_block_base_fee(spec.base_fee_params_at_timestamp(next_timestamp))
+            .unwrap_or_default();
+
+        let got = spec.next_block_base_fee(&parent, next_timestamp).unwrap_or_default();
+        assert_eq!(expected, got, "Base fee calculation does not match expected value");
+    }
 }

crates/consensus/common/src/validation.rs

@@ -3,7 +3,7 @@
 use alloy_consensus::{
     constants::MAXIMUM_EXTRA_DATA_SIZE, BlockHeader as _, EMPTY_OMMER_ROOT_HASH,
 };
-use alloy_eips::{calc_next_block_base_fee, eip4844::DATA_GAS_PER_BLOB, eip7840::BlobParams};
+use alloy_eips::{eip4844::DATA_GAS_PER_BLOB, eip7840::BlobParams};
 use reth_chainspec::{EthChainSpec, EthereumHardfork, EthereumHardforks};
 use reth_consensus::ConsensusError;
 use reth_primitives_traits::{
@@ -266,15 +266,9 @@ pub fn validate_against_parent_eip1559_base_fee<
         {
             alloy_eips::eip1559::INITIAL_BASE_FEE
         } else {
-            // This BaseFeeMissing will not happen as previous blocks are checked to have
-            // them.
-            let base_fee = parent.base_fee_per_gas().ok_or(ConsensusError::BaseFeeMissing)?;
-            calc_next_block_base_fee(
-                parent.gas_used(),
-                parent.gas_limit(),
-                base_fee,
-                chain_spec.base_fee_params_at_timestamp(header.timestamp()),
-            )
+            chain_spec
+                .next_block_base_fee(parent, header.timestamp())
+                .ok_or(ConsensusError::BaseFeeMissing)?
         };
         if expected_base_fee != base_fee {
             return Err(ConsensusError::BaseFeeDiff(GotExpected {

crates/ethereum/evm/src/lib.rs

@@ -214,9 +214,7 @@ where
                 BlobExcessGasAndPrice { excess_blob_gas, blob_gasprice }
             });
 
-        let mut basefee = parent.next_block_base_fee(
-            self.chain_spec().base_fee_params_at_timestamp(attributes.timestamp),
-        );
+        let mut basefee = chain_spec.next_block_base_fee(parent, attributes.timestamp);
 
         let mut gas_limit = attributes.gas_limit;
 

crates/ethereum/node/tests/e2e/rpc.rs

@@ -1,5 +1,5 @@
 use crate::utils::eth_payload_attributes;
-use alloy_eips::{calc_next_block_base_fee, eip2718::Encodable2718};
+use alloy_eips::eip2718::Encodable2718;
 use alloy_primitives::{Address, B256, U256};
 use alloy_provider::{network::EthereumWallet, Provider, ProviderBuilder, SendableTx};
 use alloy_rpc_types_beacon::relay::{
@@ -9,7 +9,7 @@ use alloy_rpc_types_beacon::relay::{
 use alloy_rpc_types_engine::{BlobsBundleV1, ExecutionPayloadV3};
 use alloy_rpc_types_eth::TransactionRequest;
 use rand::{rngs::StdRng, Rng, SeedableRng};
-use reth_chainspec::{ChainSpecBuilder, MAINNET};
+use reth_chainspec::{ChainSpecBuilder, EthChainSpec, MAINNET};
 use reth_e2e_test_utils::setup_engine;
 use reth_node_ethereum::EthereumNode;
 use reth_payload_primitives::BuiltPayload;
@@ -98,14 +98,9 @@ async fn test_fee_history() -> eyre::Result<()> {
             .unwrap()
             .header;
         for block in (latest_block + 2 - block_count)..=latest_block {
-            let expected_base_fee = calc_next_block_base_fee(
-                prev_header.gas_used,
-                prev_header.gas_limit,
-                prev_header.base_fee_per_gas.unwrap(),
-                chain_spec.base_fee_params_at_block(block),
-            );
-
             let header = provider.get_block_by_number(block.into()).await?.unwrap().header;
+            let expected_base_fee =
+                chain_spec.next_block_base_fee(&prev_header, header.timestamp).unwrap();
 
             assert_eq!(header.base_fee_per_gas.unwrap(), expected_base_fee);
             assert_eq!(

crates/optimism/chainspec/src/lib.rs

@@ -736,9 +736,7 @@ mod tests {
             genesis.hash_slow(),
             b256!("0xf712aa9241cc24369b143cf6dce85f0902a9731e70d66818a3a5845b296c73dd")
         );
-        let base_fee = genesis
-            .next_block_base_fee(BASE_MAINNET.base_fee_params_at_timestamp(genesis.timestamp))
-            .unwrap();
+        let base_fee = BASE_MAINNET.next_block_base_fee(genesis, genesis.timestamp).unwrap();
         // <https://base.blockscout.com/block/1>
         assert_eq!(base_fee, 980000000);
     }
@@ -750,9 +748,7 @@ mod tests {
             genesis.hash_slow(),
             b256!("0x0dcc9e089e30b90ddfc55be9a37dd15bc551aeee999d2e2b51414c54eaf934e4")
         );
-        let base_fee = genesis
-            .next_block_base_fee(BASE_SEPOLIA.base_fee_params_at_timestamp(genesis.timestamp))
-            .unwrap();
+        let base_fee = BASE_SEPOLIA.next_block_base_fee(genesis, genesis.timestamp).unwrap();
         // <https://base-sepolia.blockscout.com/block/1>
         assert_eq!(base_fee, 980000000);
     }
@@ -764,9 +760,7 @@ mod tests {
             genesis.hash_slow(),
             b256!("0x102de6ffb001480cc9b8b548fd05c34cd4f46ae4aa91759393db90ea0409887d")
         );
-        let base_fee = genesis
-            .next_block_base_fee(OP_SEPOLIA.base_fee_params_at_timestamp(genesis.timestamp))
-            .unwrap();
+        let base_fee = OP_SEPOLIA.next_block_base_fee(genesis, genesis.timestamp).unwrap();
         // <https://optimism-sepolia.blockscout.com/block/1>
         assert_eq!(base_fee, 980000000);
     }

crates/optimism/consensus/src/validation/mod.rs

@@ -200,9 +200,7 @@ pub fn next_block_base_fee(
     if chain_spec.is_holocene_active_at_timestamp(parent.timestamp()) {
         Ok(decode_holocene_base_fee(chain_spec, parent, timestamp)?)
     } else {
-        Ok(parent
-            .next_block_base_fee(chain_spec.base_fee_params_at_timestamp(timestamp))
-            .unwrap_or_default())
+        Ok(chain_spec.next_block_base_fee(&parent, timestamp).unwrap_or_default())
     }
 }
 
@@ -255,9 +253,7 @@ mod tests {
         let base_fee = next_block_base_fee(&op_chain_spec, &parent, 0);
         assert_eq!(
             base_fee.unwrap(),
-            parent
-                .next_block_base_fee(op_chain_spec.base_fee_params_at_timestamp(0))
-                .unwrap_or_default()
+            op_chain_spec.next_block_base_fee(&parent, 0).unwrap_or_default()
         );
     }
 
@@ -275,9 +271,7 @@ mod tests {
         let base_fee = next_block_base_fee(&op_chain_spec, &parent, 1800000005);
         assert_eq!(
             base_fee.unwrap(),
-            parent
-                .next_block_base_fee(op_chain_spec.base_fee_params_at_timestamp(0))
-                .unwrap_or_default()
+            op_chain_spec.next_block_base_fee(&parent, 0).unwrap_or_default()
         );
     }
 

crates/optimism/rpc/src/eth/mod.rs

@@ -235,7 +235,7 @@ where
     }
 
     #[inline]
-    fn fee_history_cache(&self) -> &FeeHistoryCache {
+    fn fee_history_cache(&self) -> &FeeHistoryCache<ProviderHeader<N::Provider>> {
         self.inner.eth_api.fee_history_cache()
     }
 

crates/rpc/rpc-eth-api/src/helpers/fee.rs

@@ -13,7 +13,7 @@ use reth_rpc_eth_types::{
     fee_history::calculate_reward_percentiles_for_block, EthApiError, FeeHistoryCache,
     FeeHistoryEntry, GasPriceOracle, RpcInvalidTransactionError,
 };
-use reth_storage_api::{BlockIdReader, BlockReaderIdExt, HeaderProvider};
+use reth_storage_api::{BlockIdReader, BlockReaderIdExt, HeaderProvider, ProviderHeader};
 use tracing::debug;
 
 /// Fee related functions for the [`EthApiServer`](crate::EthApiServer) trait in the
@@ -136,7 +136,8 @@ pub trait EthFees: LoadFee {
                 }
 
                 for entry in &fee_entries {
-                    base_fee_per_gas.push(entry.base_fee_per_gas as u128);
+                    base_fee_per_gas
+                        .push(entry.header.base_fee_per_gas().unwrap_or_default() as u128);
                     gas_used_ratio.push(entry.gas_used_ratio);
                     base_fee_per_blob_gas.push(entry.base_fee_per_blob_gas.unwrap_or_default());
                     blob_gas_used_ratio.push(entry.blob_gas_used_ratio);
@@ -153,8 +154,12 @@ pub trait EthFees: LoadFee {
 
                 // Also need to include the `base_fee_per_gas` and `base_fee_per_blob_gas` for the
                 // next block
-                base_fee_per_gas
-                    .push(last_entry.next_block_base_fee(self.provider().chain_spec()) as u128);
+                base_fee_per_gas.push(
+                    self.provider()
+                        .chain_spec()
+                        .next_block_base_fee(&last_entry.header, last_entry.header.timestamp())
+                        .unwrap_or_default() as u128,
+                );
 
                 base_fee_per_blob_gas.push(last_entry.next_block_blob_fee().unwrap_or_default());
             } else {
@@ -166,13 +171,12 @@ pub trait EthFees: LoadFee {
                     return Err(EthApiError::InvalidBlockRange.into())
                 }
 
-
+                let chain_spec = self.provider().chain_spec();
                 for header in &headers {
                     base_fee_per_gas.push(header.base_fee_per_gas().unwrap_or_default() as u128);
                     gas_used_ratio.push(header.gas_used() as f64 / header.gas_limit() as f64);
 
-                    let blob_params = self.provider()
-                        .chain_spec()
+                    let blob_params = chain_spec
                         .blob_params_at_timestamp(header.timestamp())
                         .unwrap_or_else(BlobParams::cancun);
 
@@ -209,18 +213,16 @@ pub trait EthFees: LoadFee {
                 // The unwrap is safe since we checked earlier that we got at least 1 header.
                 let last_header = headers.last().expect("is present");
                 base_fee_per_gas.push(
-                    last_header.next_block_base_fee(
-                    self.provider()
-                        .chain_spec()
-                        .base_fee_params_at_timestamp(last_header.timestamp())).unwrap_or_default() as u128
+                    chain_spec
+                        .next_block_base_fee(last_header.header(), last_header.timestamp())
+                        .unwrap_or_default() as u128,
                 );
-
                 // Same goes for the `base_fee_per_blob_gas`:
                 // > "[..] includes the next block after the newest of the returned range, because this value can be derived from the newest block.
                 base_fee_per_blob_gas.push(
                     last_header
                     .maybe_next_block_blob_fee(
-                        self.provider().chain_spec().blob_params_at_timestamp(last_header.timestamp())
+                        chain_spec.blob_params_at_timestamp(last_header.timestamp())
                     ).unwrap_or_default()
                 );
             };
@@ -238,7 +240,11 @@ pub trait EthFees: LoadFee {
 
     /// Approximates reward at a given percentile for a specific block
     /// Based on the configured resolution
-    fn approximate_percentile(&self, entry: &FeeHistoryEntry, requested_percentile: f64) -> u128 {
+    fn approximate_percentile(
+        &self,
+        entry: &FeeHistoryEntry<ProviderHeader<Self::Provider>>,
+        requested_percentile: f64,
+    ) -> u128 {
         let resolution = self.fee_history_cache().resolution();
         let rounded_percentile =
             (requested_percentile * resolution as f64).round() / resolution as f64;
@@ -266,7 +272,7 @@ where
     /// Returns a handle for reading fee history data from memory.
     ///
     /// Data access in default (L1) trait method implementations.
-    fn fee_history_cache(&self) -> &FeeHistoryCache;
+    fn fee_history_cache(&self) -> &FeeHistoryCache<ProviderHeader<Self::Provider>>;
 
     /// Returns the gas price if it is set, otherwise fetches a suggested gas price for legacy
     /// transactions.