Use latest block state for metering instead of bundle.block_number

Bundle metering now always uses the latest available block state for
simulation. The bundle.block_number parameter is only used for TIPS
bundle validity checks, not for state selection.

Author: niran

crates/metering/README.md

@@ -11,7 +11,7 @@ Simulates a bundle of transactions, providing gas usage and execution time metri
 The method accepts a Bundle object with the following fields:
 
 - `txs`: Array of signed, RLP-encoded transactions (hex strings with 0x prefix)
-- `block_number`: Target block number (used both for bundle validity and as the state block for simulation)
+- `block_number`: Target block number for bundle validity (note: simulation always uses the latest available block state)
 - `min_timestamp` (optional): Minimum timestamp for bundle validity (also used as simulation timestamp if provided)
 - `max_timestamp` (optional): Maximum timestamp for bundle validity
 - `reverting_tx_hashes` (optional): Array of transaction hashes allowed to revert
@@ -26,7 +26,7 @@ The method accepts a Bundle object with the following fields:
 - `coinbaseDiff`: Total gas fees paid
 - `ethSentToCoinbase`: ETH sent directly to coinbase
 - `gasFees`: Total gas fees
-- `stateBlockNumber`: Block number used for state
+- `stateBlockNumber`: Block number used for state (always the latest available block)
 - `totalGasUsed`: Total gas consumed
 - `totalExecutionTimeUs`: Total execution time (μs)
 - `results`: Array of per-transaction results:

crates/metering/src/rpc.rs

@@ -1,5 +1,6 @@
 use alloy_consensus::Header;
 use alloy_eips::eip2718::Decodable2718;
+use alloy_eips::BlockNumberOrTag;
 use alloy_primitives::U256;
 use jsonrpsee::{
     core::{async_trait, RpcResult},
@@ -57,21 +58,21 @@ where
             "Starting bundle metering"
         );
 
-        // Get the header
+        // Get the latest header
         let header = self
             .provider
-            .sealed_header(bundle.block_number)
+            .sealed_header_by_number_or_tag(BlockNumberOrTag::Latest)
             .map_err(|e| {
                 jsonrpsee::types::ErrorObjectOwned::owned(
                     jsonrpsee::types::ErrorCode::InternalError.code(),
-                    format!("Failed to get header: {}", e),
+                    format!("Failed to get latest header: {}", e),
                     None::<()>,
                 )
             })?
             .ok_or_else(|| {
                 jsonrpsee::types::ErrorObjectOwned::owned(
-                    jsonrpsee::types::ErrorCode::InvalidParams.code(),
-                    format!("Block {} not found", bundle.block_number),
+                    jsonrpsee::types::ErrorCode::InternalError.code(),
+                    "Latest block not found".to_string(),
                     None::<()>,
                 )
             })?;
@@ -153,7 +154,7 @@ where
             eth_sent_to_coinbase: "0".to_string(),
             gas_fees: result.total_gas_fees.to_string(),
             results: result.results,
-            state_block_number: bundle.block_number,
+            state_block_number: header.number,
             total_gas_used: result.total_gas_used,
             total_execution_time_us: result.total_execution_time_us,
             state_root_time_us: result.state_root_time_us,

crates/metering/src/tests/rpc.rs

@@ -291,19 +291,48 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_meter_bundle_uses_block_number() -> eyre::Result<()> {
+    async fn test_meter_bundle_uses_latest_block() -> eyre::Result<()> {
         reth_tracing::init_test_tracing();
         let node = setup_node().await?;
         let client = node.rpc_client().await?;
 
-        // Bundle.block_number is used as the state block for simulation
+        // Metering always uses the latest block state, regardless of bundle.block_number
         let bundle = create_bundle(vec![], 0, None);
 
         let response: crate::MeterBundleResponse = client
             .request("base_meterBundle", (bundle,))
             .await?;
 
-        assert_eq!(response.state_block_number, 0); // Uses bundle.block_number
+        // Should return the latest block number (genesis block 0)
+        assert_eq!(response.state_block_number, 0);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_meter_bundle_ignores_bundle_block_number() -> eyre::Result<()> {
+        reth_tracing::init_test_tracing();
+        let node = setup_node().await?;
+        let client = node.rpc_client().await?;
+
+        // Even if bundle.block_number is different, it should use the latest block
+        // In this test, we specify block_number=0 in the bundle
+        let bundle1 = create_bundle(vec![], 0, None);
+        let response1: crate::MeterBundleResponse = client
+            .request("base_meterBundle", (bundle1,))
+            .await?;
+
+        // Try with a different bundle.block_number (999 - arbitrary value)
+        // Since we can't create future blocks, we use a different value to show it's ignored
+        let bundle2 = create_bundle(vec![], 999, None);
+        let response2: crate::MeterBundleResponse = client
+            .request("base_meterBundle", (bundle2,))
+            .await?;
+
+        // Both should return the same state_block_number (the latest block)
+        // because the implementation always uses Latest, not bundle.block_number
+        assert_eq!(response1.state_block_number, response2.state_block_number);
+        assert_eq!(response1.state_block_number, 0); // Genesis block
 
         Ok(())
     }
@@ -332,18 +361,21 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_meter_bundle_nonexistent_block() -> eyre::Result<()> {
+    async fn test_meter_bundle_arbitrary_block_number() -> eyre::Result<()> {
         reth_tracing::init_test_tracing();
         let node = setup_node().await?;
         let client = node.rpc_client().await?;
 
-        let bundle = create_bundle(vec![], 999999, None); // Non-existent block
+        // Since we now ignore bundle.block_number and always use the latest block,
+        // any block_number value should work (it's only used for bundle validity in TIPS)
+        let bundle = create_bundle(vec![], 999999, None);
 
-        let result: Result<crate::MeterBundleResponse, _> = client
+        let response: crate::MeterBundleResponse = client
             .request("base_meterBundle", (bundle,))
-            .await;
+            .await?;
 
-        assert!(result.is_err());
+        // Should succeed and use the latest block (genesis block 0)
+        assert_eq!(response.state_block_number, 0);
 
         Ok(())
     }