refactor: simplify meter_block API by accepting provider directly

Instead of requiring the caller to pass a state provider and parent
header separately, meter_block now accepts a provider that implements
both StateProviderFactory and HeaderProvider. This allows the function
to fetch the parent header and state internally, resulting in a cleaner
API.

Author: niran

crates/rpc/src/base/block.rs

@@ -1,21 +1,21 @@
 use std::{sync::Arc, time::Instant};
 
-use alloy_consensus::{BlockHeader, transaction::SignerRecoverable};
+use alloy_consensus::{BlockHeader, Header, transaction::SignerRecoverable};
 use alloy_primitives::B256;
 use eyre::{Result as EyreResult, eyre};
 use reth::revm::db::State;
 use reth_evm::{ConfigureEvm, execute::BlockBuilder};
 use reth_optimism_chainspec::OpChainSpec;
 use reth_optimism_evm::{OpEvmConfig, OpNextBlockEnvAttributes};
 use reth_optimism_primitives::OpBlock;
-use reth_primitives_traits::{Block as BlockT, SealedHeader};
-use reth_provider::{HashedPostStateProvider, StateRootProvider};
+use reth_primitives_traits::Block as BlockT;
+use reth_provider::{HeaderProvider, StateProviderFactory};
 
 use super::types::{MeterBlockResponse, MeterBlockTransactions};
 
 /// Re-executes a block and meters execution time, state root calculation time, and total time.
 ///
-/// Takes a state provider at the parent block, the chain spec, and the block to meter.
+/// Takes a provider, the chain spec, and the block to meter.
 ///
 /// Returns `MeterBlockResponse` containing:
 /// - Block hash
@@ -32,20 +32,28 @@ use super::types::{MeterBlockResponse, MeterBlockTransactions};
 /// State root calculation timing is most accurate for recent blocks where state tries are
 /// cached. For older blocks, trie nodes may not be cached, which can significantly inflate
 /// the `state_root_time_us` value.
-pub fn meter_block<SP>(
-    state_provider: SP,
+pub fn meter_block<P>(
+    provider: P,
     chain_spec: Arc<OpChainSpec>,
     block: &OpBlock,
-    parent_header: &SealedHeader,
 ) -> EyreResult<MeterBlockResponse>
 where
-    SP: reth_provider::StateProvider + StateRootProvider + HashedPostStateProvider,
+    P: StateProviderFactory + HeaderProvider<Header = Header>,
 {
     let block_hash = block.header().hash_slow();
     let block_number = block.header().number();
     let transactions: Vec<_> = block.body().transactions().cloned().collect();
     let tx_count = transactions.len();
 
+    // Get parent header
+    let parent_hash = block.header().parent_hash();
+    let parent_header = provider
+        .sealed_header_by_hash(parent_hash)?
+        .ok_or_else(|| eyre!("Parent header not found: {}", parent_hash))?;
+
+    // Get state provider at parent block
+    let state_provider = provider.state_by_block_hash(parent_hash)?;
+
     // Create state database from parent state
     let state_db = reth::revm::database::StateProviderDatabase::new(&state_provider);
     let mut db = State::builder().with_database(state_db).with_bundle_update().build();
@@ -80,7 +88,7 @@ where
     let evm_start = Instant::now();
     {
         let evm_config = OpEvmConfig::optimism(chain_spec);
-        let mut builder = evm_config.builder_for_next_block(&mut db, parent_header, attributes)?;
+        let mut builder = evm_config.builder_for_next_block(&mut db, &parent_header, attributes)?;
 
         builder.apply_pre_execution_changes()?;
 

crates/rpc/src/base/meter_rpc.rs

@@ -5,8 +5,7 @@ use jsonrpsee::core::{RpcResult, async_trait};
 use reth::providers::BlockReaderIdExt;
 use reth_optimism_chainspec::OpChainSpec;
 use reth_optimism_primitives::OpBlock;
-use reth_primitives_traits::Block as BlockT;
-use reth_provider::{BlockReader, ChainSpecProvider, StateProviderFactory};
+use reth_provider::{BlockReader, ChainSpecProvider, HeaderProvider, StateProviderFactory};
 use tips_core::types::{Bundle, MeterBundleResponse, ParsedBundle};
 use tracing::{error, info};
 
@@ -27,6 +26,7 @@ where
         + ChainSpecProvider<ChainSpec = OpChainSpec>
         + BlockReaderIdExt<Header = Header>
         + BlockReader<Block = OpBlock>
+        + HeaderProvider<Header = Header>
         + Clone,
 {
     /// Creates a new instance of MeteringApi
@@ -42,6 +42,7 @@ where
         + ChainSpecProvider<ChainSpec = OpChainSpec>
         + BlockReaderIdExt<Header = Header>
         + BlockReader<Block = OpBlock>
+        + HeaderProvider<Header = Header>
         + Clone
         + Send
         + Sync
@@ -212,58 +213,23 @@ where
         + ChainSpecProvider<ChainSpec = OpChainSpec>
         + BlockReaderIdExt<Header = Header>
         + BlockReader<Block = OpBlock>
+        + HeaderProvider<Header = Header>
         + Clone
         + Send
         + Sync
         + 'static,
 {
     /// Internal helper to meter a block's execution
     fn meter_block_internal(&self, block: &OpBlock) -> RpcResult<MeterBlockResponse> {
-        // Get parent header
-        let parent_hash = block.header().parent_hash;
-        let parent_header = self
-            .provider
-            .sealed_header_by_hash(parent_hash)
-            .map_err(|e| {
-                error!(error = %e, "Failed to get parent header");
+        meter_block(self.provider.clone(), self.provider.chain_spec().clone(), block).map_err(
+            |e| {
+                error!(error = %e, "Block metering failed");
                 jsonrpsee::types::ErrorObjectOwned::owned(
                     jsonrpsee::types::ErrorCode::InternalError.code(),
-                    format!("Failed to get parent header: {}", e),
+                    format!("Block metering failed: {}", e),
                     None::<()>,
                 )
-            })?
-            .ok_or_else(|| {
-                jsonrpsee::types::ErrorObjectOwned::owned(
-                    jsonrpsee::types::ErrorCode::InternalError.code(),
-                    format!("Parent block not found: {}", parent_hash),
-                    None::<()>,
-                )
-            })?;
-
-        // Get state provider at parent block
-        let state_provider = self.provider.state_by_block_hash(parent_hash).map_err(|e| {
-            error!(error = %e, "Failed to get state provider for parent block");
-            jsonrpsee::types::ErrorObjectOwned::owned(
-                jsonrpsee::types::ErrorCode::InternalError.code(),
-                format!("Failed to get state provider: {}", e),
-                None::<()>,
-            )
-        })?;
-
-        // Meter the block
-        meter_block(
-            state_provider,
-            self.provider.chain_spec().clone(),
-            block,
-            &parent_header,
+            },
         )
-        .map_err(|e| {
-            error!(error = %e, "Block metering failed");
-            jsonrpsee::types::ErrorObjectOwned::owned(
-                jsonrpsee::types::ErrorCode::InternalError.code(),
-                format!("Block metering failed: {}", e),
-                None::<()>,
-            )
-        })
     }
 }

crates/rpc/tests/meter_block.rs

@@ -14,8 +14,8 @@ use reth_db::{DatabaseEnv, test_utils::TempDatabase};
 use reth_optimism_chainspec::{BASE_MAINNET, OpChainSpec, OpChainSpecBuilder};
 use reth_optimism_node::OpNode;
 use reth_optimism_primitives::{OpBlock, OpBlockBody, OpTransactionSigned};
-use reth_primitives_traits::{Block as BlockT, SealedHeader};
-use reth_provider::{HeaderProvider, StateProviderFactory, providers::BlockchainProvider};
+use reth_primitives_traits::Block as BlockT;
+use reth_provider::{HeaderProvider, providers::BlockchainProvider};
 use reth_testing_utils::generators::generate_keys;
 use reth_transaction_pool::test_utils::TransactionBuilder;
 
@@ -30,7 +30,9 @@ enum User {
 #[derive(Debug, Clone)]
 struct TestHarness {
     provider: BlockchainProvider<NodeTypes>,
-    header: SealedHeader,
+    genesis_header_hash: B256,
+    genesis_header_number: u64,
+    genesis_header_timestamp: u64,
     chain_spec: Arc<OpChainSpec>,
     user_to_private_key: std::collections::HashMap<User, B256>,
 }
@@ -83,17 +85,24 @@ fn setup_harness() -> eyre::Result<TestHarness> {
         .context("fetching genesis header")?
         .expect("genesis header exists");
 
-    Ok(TestHarness { provider, header, chain_spec, user_to_private_key })
+    Ok(TestHarness {
+        provider,
+        genesis_header_hash: header.hash(),
+        genesis_header_number: header.number(),
+        genesis_header_timestamp: header.timestamp(),
+        chain_spec,
+        user_to_private_key,
+    })
 }
 
 fn create_block_with_transactions(
     harness: &TestHarness,
     transactions: Vec<OpTransactionSigned>,
 ) -> OpBlock {
     let header = Header {
-        parent_hash: harness.header.hash(),
-        number: harness.header.number() + 1,
-        timestamp: harness.header.timestamp() + 2,
+        parent_hash: harness.genesis_header_hash,
+        number: harness.genesis_header_number + 1,
+        timestamp: harness.genesis_header_timestamp + 2,
         gas_limit: 30_000_000,
         beneficiary: Address::random(),
         base_fee_per_gas: Some(1),
@@ -113,13 +122,7 @@ fn meter_block_empty_transactions() -> eyre::Result<()> {
 
     let block = create_block_with_transactions(&harness, vec![]);
 
-    let state_provider = harness
-        .provider
-        .state_by_block_hash(harness.header.hash())
-        .context("getting state provider")?;
-
-    let response =
-        meter_block(state_provider, harness.chain_spec.clone(), &block, &harness.header)?;
+    let response = meter_block(harness.provider.clone(), harness.chain_spec.clone(), &block)?;
 
     assert_eq!(response.block_hash, block.header().hash_slow());
     assert_eq!(response.block_number, block.header().number());
@@ -157,13 +160,7 @@ fn meter_block_single_transaction() -> eyre::Result<()> {
 
     let block = create_block_with_transactions(&harness, vec![tx]);
 
-    let state_provider = harness
-        .provider
-        .state_by_block_hash(harness.header.hash())
-        .context("getting state provider")?;
-
-    let response =
-        meter_block(state_provider, harness.chain_spec.clone(), &block, &harness.header)?;
+    let response = meter_block(harness.provider.clone(), harness.chain_spec.clone(), &block)?;
 
     assert_eq!(response.block_hash, block.header().hash_slow());
     assert_eq!(response.block_number, block.header().number());
@@ -228,13 +225,7 @@ fn meter_block_multiple_transactions() -> eyre::Result<()> {
 
     let block = create_block_with_transactions(&harness, vec![tx_1, tx_2]);
 
-    let state_provider = harness
-        .provider
-        .state_by_block_hash(harness.header.hash())
-        .context("getting state provider")?;
-
-    let response =
-        meter_block(state_provider, harness.chain_spec.clone(), &block, &harness.header)?;
+    let response = meter_block(harness.provider.clone(), harness.chain_spec.clone(), &block)?;
 
     assert_eq!(response.block_hash, block.header().hash_slow());
     assert_eq!(response.block_number, block.header().number());
@@ -292,13 +283,7 @@ fn meter_block_timing_consistency() -> eyre::Result<()> {
 
     let block = create_block_with_transactions(&harness, vec![tx]);
 
-    let state_provider = harness
-        .provider
-        .state_by_block_hash(harness.header.hash())
-        .context("getting state provider")?;
-
-    let response =
-        meter_block(state_provider, harness.chain_spec.clone(), &block, &harness.header)?;
+    let response = meter_block(harness.provider.clone(), harness.chain_spec.clone(), &block)?;
 
     // Verify timing invariants
     assert!(response.signer_recovery_time_us > 0, "signer recovery time must be positive");