Fix build issues after rebase

- Fix load_account -> load_cache_account in processor.rs (State API differs from CacheDB)
- Add FB generic parameter to MeteringApiImpl for flashblocks support
- Fix revm module paths in tests (revm:: -> reth::revm::)
- Add DummyFlashblocks implementation for meter_rpc tests
- Add dev-dependencies: alloy-genesis, reth-optimism-node
- Remove non-existent pub mod flashblocks from test-utils

Author: niran

Cargo.lock

@@ -61,12 +61,14 @@ metrics-derive.workspace = true
 rayon.workspace = true
 
 [dev-dependencies]
+alloy-genesis.workspace = true
 rand.workspace = true
 revm.workspace = true
 reth-db.workspace = true
 once_cell.workspace = true
 reth-provider.workspace = true
 reth-db-common.workspace = true
+reth-optimism-node.workspace = true
 alloy-rpc-client.workspace = true
 op-alloy-consensus.workspace = true
 reth-testing-utils.workspace = true

crates/flashblocks/Cargo.toml

@@ -32,7 +32,6 @@ use reth::{
     },
 };
 use reth_evm::{ConfigureEvm, Evm, eth::receipt_builder::ReceiptBuilderCtx};
-use revm_database::states::bundle_state::BundleRetention;
 use reth_optimism_chainspec::OpHardforks;
 use reth_optimism_evm::{OpEvmConfig, OpNextBlockEnvAttributes};
 use reth_optimism_primitives::{OpBlock, OpPrimitives};
@@ -551,8 +550,12 @@ where
                                         && transaction.is_deposit())
                                     .then(|| {
                                         evm.db_mut()
-                                            .load_account(recovered_transaction.signer())
-                                            .map(|acc| acc.info.nonce)
+                                            .load_cache_account(recovered_transaction.signer())
+                                            .map(|acc| {
+                                                acc.account_info()
+                                                    .map(|info| info.nonce)
+                                                    .unwrap_or(0)
+                                            })
                                     })
                                     .transpose()
                                     .map_err(|_| {

crates/flashblocks/src/processor.rs

@@ -13,8 +13,8 @@ use reth_provider::{BlockReader, ChainSpecProvider, HeaderProvider, StateProvide
 use tips_core::types::{Bundle, MeterBundleResponse, ParsedBundle};
 use tracing::{error, info};
 
-use crate::{FlashblockTrieCache, MeteringApiServer, meter_bundle};
 use super::{block::meter_block, types::MeterBlockResponse};
+use crate::{FlashblockTrieCache, MeteringApiServer, meter_bundle};
 
 /// Implementation of the metering RPC API.
 #[derive(Debug)]
@@ -289,7 +289,7 @@ where
     }
 }
 
-impl<Provider> MeteringApiImpl<Provider>
+impl<Provider, FB> MeteringApiImpl<Provider, FB>
 where
     Provider: StateProviderFactory
         + ChainSpecProvider<ChainSpec = OpChainSpec>
@@ -300,6 +300,7 @@ where
         + Send
         + Sync
         + 'static,
+    FB: FlashblocksAPI + Send + Sync + 'static,
 {
     /// Internal helper to meter a block's execution
     fn meter_block_internal(&self, block: &OpBlock) -> RpcResult<MeterBlockResponse> {

crates/rpc/src/base/meter_rpc.rs

@@ -14,7 +14,10 @@ use rand::{SeedableRng, rngs::StdRng};
 use reth::{
     api::NodeTypesWithDBAdapter,
     chainspec::EthChainSpec,
-    revm::db::{BundleState, Cache},
+    revm::{
+        db::{BundleState, Cache},
+        primitives::KECCAK_EMPTY,
+    },
 };
 use reth_db::{DatabaseEnv, test_utils::TempDatabase};
 use reth_optimism_chainspec::{BASE_MAINNET, OpChainSpec, OpChainSpecBuilder};
@@ -24,7 +27,6 @@ use reth_primitives_traits::SealedHeader;
 use reth_provider::{HeaderProvider, StateProviderFactory, providers::BlockchainProvider};
 use reth_testing_utils::generators::generate_keys;
 use reth_transaction_pool::test_utils::TransactionBuilder;
-use revm::primitives::KECCAK_EMPTY;
 use tips_core::types::{Bundle, ParsedBundle};
 
 type NodeTypes = NodeTypesWithDBAdapter<OpNode, Arc<TempDatabase<DatabaseEnv>>>;
@@ -426,25 +428,26 @@ fn meter_bundle_requires_correct_layering_for_pending_nonce() -> eyre::Result<()
     let bundle_state = BundleState::new(
         [(
             alice_address,
-            Some(revm::state::AccountInfo {
+            Some(reth::revm::state::AccountInfo {
                 balance: U256::from(1_000_000_000u64),
                 nonce: 0, // original
                 code_hash: KECCAK_EMPTY,
                 code: None,
             }),
-            Some(revm::state::AccountInfo {
+            Some(reth::revm::state::AccountInfo {
                 balance: U256::from(1_000_000_000u64),
                 nonce: 1, // pending (after first flashblock tx)
                 code_hash: KECCAK_EMPTY,
                 code: None,
             }),
             Default::default(), // no storage changes
         )],
-        Vec::<Vec<(Address, Option<Option<revm::state::AccountInfo>>, Vec<(U256, U256)>)>>::new(),
-        Vec::<(B256, revm::bytecode::Bytecode)>::new(),
+        Vec::<Vec<(Address, Option<Option<reth::revm::state::AccountInfo>>, Vec<(U256, U256)>)>>::new(),
+        Vec::<(B256, reth::revm::bytecode::Bytecode)>::new(),
     );
 
-    let flashblocks_state = FlashblocksState { cache: Cache::default(), bundle_state };
+    let flashblocks_state =
+        base_reth_rpc::FlashblocksState { cache: Cache::default(), bundle_state };
 
     // With correct flashblocks state, transaction should succeed
     let state_provider2 = harness

crates/rpc/tests/meter.rs

@@ -5,6 +5,8 @@ use std::{any::Any, net::SocketAddr, sync::Arc};
 use alloy_eips::Encodable2718;
 use alloy_primitives::{Bytes, U256, address, b256, bytes};
 use alloy_rpc_client::RpcClient;
+use arc_swap::Guard;
+use base_reth_flashblocks::{FlashblocksAPI, PendingBlocks};
 use base_reth_rpc::{MeterBundleResponse, MeteringApiImpl, MeteringApiServer};
 use base_reth_test_utils::{init_silenced_tracing, load_genesis};
 use op_alloy_consensus::OpTxEnvelope;
@@ -21,13 +23,37 @@ use reth_optimism_primitives::OpTransactionSigned;
 use reth_provider::providers::BlockchainProvider;
 use reth_transaction_pool::test_utils::TransactionBuilder;
 use tips_core::types::Bundle;
+use tokio::sync::broadcast;
 
 struct NodeContext {
     http_api_addr: SocketAddr,
     _node_exit_future: NodeExitFuture,
     _node: Box<dyn Any + Sync + Send>,
 }
 
+/// Dummy FlashblocksAPI implementation for tests that don't need flashblock state
+struct DummyFlashblocks {
+    pending_blocks: arc_swap::ArcSwapOption<PendingBlocks>,
+}
+
+impl Default for DummyFlashblocks {
+    fn default() -> Self {
+        Self { pending_blocks: arc_swap::ArcSwapOption::new(None) }
+    }
+}
+
+impl FlashblocksAPI for DummyFlashblocks {
+    fn get_pending_blocks(&self) -> Guard<Option<Arc<PendingBlocks>>> {
+        self.pending_blocks.load()
+    }
+
+    fn subscribe_to_flashblocks(&self) -> broadcast::Receiver<Arc<PendingBlocks>> {
+        let (tx, rx) = broadcast::channel(1);
+        drop(tx);
+        rx
+    }
+}
+
 // Helper function to create a Bundle with default fields
 fn create_bundle(txs: Vec<Bytes>, block_number: u64, min_timestamp: Option<u64>) -> Bundle {
     Bundle {
@@ -84,7 +110,8 @@ async fn setup_node() -> eyre::Result<NodeContext> {
         .with_components(node.components_builder())
         .with_add_ons(node.add_ons())
         .extend_rpc_modules(move |ctx| {
-            let metering_api = MeteringApiImpl::new(ctx.provider().clone());
+            let metering_api =
+                MeteringApiImpl::new(ctx.provider().clone(), Arc::new(DummyFlashblocks::default()));
             ctx.modules.merge_configured(metering_api.into_rpc())?;
             Ok(())
         })

crates/rpc/tests/meter_rpc.rs

@@ -21,8 +21,6 @@ pub use engine::{EngineAddress, EngineApi, EngineProtocol, HttpEngine, IpcEngine
 mod fixtures;
 pub use fixtures::{create_provider_factory, load_genesis};
 
-pub mod flashblocks;
-
 mod flashblocks_harness;
 pub use flashblocks_harness::FlashblocksHarness;