blockifier_reexecution: use StateReaderAndContractManager in reexecution crate

Yonatan-Starkware · AvivYossef-starkware · commit bad84a10b7c3 · 2025-12-10T16:55:28.000+02:00
diff --git a/crates/blockifier_reexecution/Cargo.toml b/crates/blockifier_reexecution/Cargo.toml
@@ -7,6 +7,7 @@ license.workspace = true
 
 [features]
 blockifier_regression_https_testing = []
+cairo_native = ["blockifier/cairo_native"]
 
 [dependencies]
 apollo_compile_to_casm.workspace = true
diff --git a/crates/blockifier_reexecution/src/main.rs b/crates/blockifier_reexecution/src/main.rs
@@ -2,6 +2,8 @@ use std::fs;
 use std::path::Path;
 
 use apollo_gateway_config::config::RpcStateReaderConfig;
+use blockifier::blockifier::config::ContractClassManagerConfig;
+use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier_reexecution::state_reader::cli::{
     parse_block_numbers_args,
     BlockifierReexecutionCliArgs,
@@ -50,24 +52,32 @@ async fn main() {
             + RESOURCES_DIR
     };
 
+    // Initialize the contract class manager.
+    let mut contract_class_manager_config = ContractClassManagerConfig::default();
+    if cfg!(feature = "cairo_native") {
+        contract_class_manager_config.cairo_native_run_config.wait_on_native_compilation = true;
+        contract_class_manager_config.cairo_native_run_config.run_cairo_native = true;
+    }
+    let contract_class_manager = ContractClassManager::start(contract_class_manager_config);
+
     match args.command {
         Command::RpcTest { block_number, rpc_args } => {
             println!(
                 "Running RPC test for block number {block_number} using node url {}.",
                 rpc_args.node_url
             );
 
-            let config = RpcStateReaderConfig::from_url(rpc_args.node_url.clone());
-
+            let rpc_state_reader_config = RpcStateReaderConfig::from_url(rpc_args.node_url.clone());
             // RPC calls are "synchronous IO" (see, e.g., https://stackoverflow.com/questions/74547541/when-should-you-use-tokios-spawn-blocking)
             // for details), so should be executed in a blocking thread.
             // TODO(Aner): make only the RPC calls blocking, not the whole function.
             tokio::task::spawn_blocking(move || {
                 reexecute_and_verify_correctness(ConsecutiveTestStateReaders::new(
                     BlockNumber(block_number - 1),
-                    Some(config),
+                    Some(rpc_state_reader_config),
                     rpc_args.parse_chain_id(),
                     false,
+                    contract_class_manager,
                 ))
             })
             .await
@@ -92,11 +102,17 @@ async fn main() {
 
             let (node_url, chain_id) = (rpc_args.node_url.clone(), rpc_args.parse_chain_id());
 
-            // RPC calls are "synchronous IO" (see, e.g., https://stackoverflow.com/questions/74547541/when-should-you-use-tokios-spawn-blocking)
+            // RPC calls are "synchronous IO" (see, e.g., https://stackoverflow.com/questions/74547541/when-should-you-use-tokios-spawn_blocking)
             // for details), so should be executed in a blocking thread.
             // TODO(Aner): make only the RPC calls blocking, not the whole function.
             tokio::task::spawn_blocking(move || {
-                execute_single_transaction(BlockNumber(block_number), node_url, chain_id, tx_input)
+                execute_single_transaction(
+                    BlockNumber(block_number),
+                    node_url,
+                    chain_id,
+                    tx_input,
+                    contract_class_manager,
+                )
             })
             .await
             .unwrap()
@@ -115,6 +131,8 @@ async fn main() {
             for block_number in block_numbers {
                 let full_file_path = block_full_file_path(directory_path.clone(), block_number);
                 let (node_url, chain_id) = (rpc_args.node_url.clone(), rpc_args.parse_chain_id());
+                let contract_class_manager = contract_class_manager.clone();
+
                 // RPC calls are "synchronous IO" (see, e.g., https://stackoverflow.com/questions/74547541/when-should-you-use-tokios-spawn-blocking)
                 // for details), so should be executed in a blocking thread.
                 // TODO(Aner): make only the RPC calls blocking, not the whole function.
@@ -126,6 +144,7 @@ async fn main() {
                             full_file_path,
                             node_url,
                             chain_id,
+                            contract_class_manager,
                         )
                     })
                     .await
@@ -144,9 +163,14 @@ async fn main() {
             let mut task_set = tokio::task::JoinSet::new();
             for block in block_numbers {
                 let full_file_path = block_full_file_path(directory_path.clone(), block);
+                let contract_class_manager = contract_class_manager.clone();
                 task_set.spawn(async move {
                     reexecute_and_verify_correctness(
-                        OfflineConsecutiveStateReaders::new_from_file(&full_file_path).unwrap(),
+                        OfflineConsecutiveStateReaders::new_from_file(
+                            &full_file_path,
+                            contract_class_manager,
+                        )
+                        .unwrap(),
                     );
                     println!("Reexecution test for block {block} passed successfully.");
                 });
diff --git a/crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs b/crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs
@@ -8,10 +8,14 @@ use blockifier::bouncer::BouncerConfig;
 use blockifier::context::BlockContext;
 use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::state::cached_state::{CommitmentStateDiff, StateMaps};
+use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::state::errors::StateError;
 use blockifier::state::global_cache::CompiledClasses;
 use blockifier::state::state_api::{StateReader, StateResult};
-use blockifier::state::state_reader_and_contract_manager::FetchCompiledClasses;
+use blockifier::state::state_reader_and_contract_manager::{
+    FetchCompiledClasses,
+    StateReaderAndContractManager,
+};
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
 use serde::{Deserialize, Serialize};
 use starknet_api::block::{BlockHash, BlockHashAndNumber, BlockInfo, BlockNumber, StarknetVersion};
@@ -213,14 +217,23 @@ impl OfflineStateReader {
         self,
         block_context_next_block: BlockContext,
         transaction_executor_config: Option<TransactionExecutorConfig>,
-    ) -> ReexecutionResult<TransactionExecutor<OfflineStateReader>> {
+        contract_class_manager: &ContractClassManager,
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<OfflineStateReader>>>
+    {
         let old_block_number = BlockNumber(
             block_context_next_block.block_info().block_number.0
                 - constants::STORED_BLOCK_HASH_BUFFER,
         );
         let hash = self.old_block_hash;
-        Ok(TransactionExecutor::<OfflineStateReader>::pre_process_and_create(
+        // We don't collect class cache metrics for the reexecution.
+        let class_cache_metrics = None;
+        let state_reader_and_contract_manager = StateReaderAndContractManager::new(
             self,
+            contract_class_manager.clone(),
+            class_cache_metrics,
+        );
+        Ok(TransactionExecutor::<StateReaderAndContractManager<OfflineStateReader>>::pre_process_and_create(
+            state_reader_and_contract_manager,
             block_context_next_block,
             Some(BlockHashAndNumber { number: old_block_number, hash }),
             transaction_executor_config.unwrap_or_default(),
@@ -233,13 +246,17 @@ pub struct OfflineConsecutiveStateReaders {
     pub block_context_next_block: BlockContext,
     pub transactions_next_block: Vec<BlockifierTransaction>,
     pub state_diff_next_block: CommitmentStateDiff,
+    contract_class_manager: ContractClassManager,
 }
 
 impl OfflineConsecutiveStateReaders {
-    pub fn new_from_file(full_file_path: &str) -> ReexecutionResult<Self> {
+    pub fn new_from_file(
+        full_file_path: &str,
+        contract_class_manager: ContractClassManager,
+    ) -> ReexecutionResult<Self> {
         let serializable_offline_reexecution_data =
             SerializableOfflineReexecutionData::read_from_file(full_file_path)?;
-        Ok(Self::new(serializable_offline_reexecution_data.into()))
+        Ok(Self::new(serializable_offline_reexecution_data.into(), contract_class_manager))
     }
 
     pub fn new(
@@ -249,23 +266,31 @@ impl OfflineConsecutiveStateReaders {
             transactions_next_block,
             state_diff_next_block,
         }: OfflineReexecutionData,
+        contract_class_manager: ContractClassManager,
     ) -> Self {
         Self {
             offline_state_reader_prev_block,
             block_context_next_block,
             transactions_next_block,
             state_diff_next_block,
+            contract_class_manager,
         }
     }
 }
 
-impl ConsecutiveReexecutionStateReaders<OfflineStateReader> for OfflineConsecutiveStateReaders {
+impl ConsecutiveReexecutionStateReaders<StateReaderAndContractManager<OfflineStateReader>>
+    for OfflineConsecutiveStateReaders
+{
     fn pre_process_and_create_executor(
         self,
         transaction_executor_config: Option<TransactionExecutorConfig>,
-    ) -> ReexecutionResult<TransactionExecutor<OfflineStateReader>> {
-        self.offline_state_reader_prev_block
-            .get_transaction_executor(self.block_context_next_block, transaction_executor_config)
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<OfflineStateReader>>>
+    {
+        self.offline_state_reader_prev_block.get_transaction_executor(
+            self.block_context_next_block,
+            transaction_executor_config,
+            &self.contract_class_manager,
+        )
     }
 
     fn get_next_block_txs(&self) -> ReexecutionResult<Vec<BlockifierTransaction>> {
diff --git a/crates/blockifier_reexecution/src/state_reader/rpc_https_test.rs b/crates/blockifier_reexecution/src/state_reader/rpc_https_test.rs
@@ -16,6 +16,8 @@ use apollo_gateway::rpc_objects::BlockId;
 use apollo_gateway::rpc_state_reader::RpcStateReader;
 use apollo_gateway_config::config::RpcStateReaderConfig;
 use assert_matches::assert_matches;
+use blockifier::blockifier::config::ContractClassManagerConfig;
+use blockifier::state::contract_class_manager::ContractClassManager;
 use rstest::{fixture, rstest};
 use starknet_api::block::{BlockInfo, BlockNumber};
 use starknet_api::class_hash;
@@ -115,11 +117,23 @@ pub fn last_constructed_block(test_block_number: BlockNumber) -> BlockNumber {
     BlockNumber(test_block_number.0 - 1)
 }
 
+#[fixture]
+pub fn contract_class_manager() -> ContractClassManager {
+    ContractClassManager::start(ContractClassManagerConfig::default())
+}
+
 #[fixture]
 pub fn test_state_readers_last_and_current_block(
     last_constructed_block: BlockNumber,
+    contract_class_manager: ContractClassManager,
 ) -> ConsecutiveTestStateReaders {
-    ConsecutiveTestStateReaders::new(last_constructed_block, None, ChainId::Mainnet, false)
+    ConsecutiveTestStateReaders::new(
+        last_constructed_block,
+        None,
+        ChainId::Mainnet,
+        false,
+        contract_class_manager,
+    )
 }
 
 /// Test that the block info can be retrieved from the RPC server.
diff --git a/crates/blockifier_reexecution/src/state_reader/test_state_reader.rs b/crates/blockifier_reexecution/src/state_reader/test_state_reader.rs
@@ -14,10 +14,14 @@ use blockifier::bouncer::BouncerConfig;
 use blockifier::context::BlockContext;
 use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::state::cached_state::CommitmentStateDiff;
+use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::state::errors::StateError;
 use blockifier::state::global_cache::CompiledClasses;
 use blockifier::state::state_api::{StateReader, StateResult};
-use blockifier::state::state_reader_and_contract_manager::FetchCompiledClasses;
+use blockifier::state::state_reader_and_contract_manager::{
+    FetchCompiledClasses,
+    StateReaderAndContractManager,
+};
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
 use serde::Serialize;
 use serde_json::{json, to_value};
@@ -289,14 +293,23 @@ impl TestStateReader {
         self,
         block_context_next_block: BlockContext,
         transaction_executor_config: Option<TransactionExecutorConfig>,
-    ) -> ReexecutionResult<TransactionExecutor<TestStateReader>> {
+        contract_class_manager: &ContractClassManager,
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<TestStateReader>>>
+    {
         let old_block_number = BlockNumber(
             block_context_next_block.block_info().block_number.0
                 - constants::STORED_BLOCK_HASH_BUFFER,
         );
         let old_block_hash = self.get_old_block_hash(old_block_number)?;
-        Ok(TransactionExecutor::<TestStateReader>::pre_process_and_create(
+        // We don't collect class cache metrics for the reexecution.
+        let class_cache_metrics = None;
+        let state_reader_and_contract_manager = StateReaderAndContractManager::new(
             self,
+            contract_class_manager.clone(),
+            class_cache_metrics,
+        );
+        Ok(TransactionExecutor::<StateReaderAndContractManager<TestStateReader>>::pre_process_and_create(
+            state_reader_and_contract_manager,
             block_context_next_block,
             Some(BlockHashAndNumber { number: old_block_number, hash: old_block_hash }),
             transaction_executor_config.unwrap_or_default(),
@@ -395,6 +408,7 @@ impl ReexecutionStateReader for TestStateReader {
 pub struct ConsecutiveTestStateReaders {
     pub last_block_state_reader: TestStateReader,
     pub next_block_state_reader: TestStateReader,
+    contract_class_manager: ContractClassManager,
 }
 
 impl ConsecutiveTestStateReaders {
@@ -403,6 +417,7 @@ impl ConsecutiveTestStateReaders {
         config: Option<RpcStateReaderConfig>,
         chain_id: ChainId,
         dump_mode: bool,
+        contract_class_manager: ContractClassManager,
     ) -> Self {
         let config = config.unwrap_or(get_rpc_state_reader_config());
         Self {
@@ -418,6 +433,7 @@ impl ConsecutiveTestStateReaders {
                 last_constructed_block_number.next().expect("Overflow in block number"),
                 dump_mode,
             ),
+            contract_class_manager,
         }
     }
 
@@ -457,14 +473,18 @@ impl ConsecutiveTestStateReaders {
     }
 }
 
-impl ConsecutiveReexecutionStateReaders<TestStateReader> for ConsecutiveTestStateReaders {
+impl ConsecutiveReexecutionStateReaders<StateReaderAndContractManager<TestStateReader>>
+    for ConsecutiveTestStateReaders
+{
     fn pre_process_and_create_executor(
         self,
         transaction_executor_config: Option<TransactionExecutorConfig>,
-    ) -> ReexecutionResult<TransactionExecutor<TestStateReader>> {
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<TestStateReader>>>
+    {
         self.last_block_state_reader.get_transaction_executor(
             self.next_block_state_reader.get_block_context()?,
             transaction_executor_config,
+            &self.contract_class_manager,
         )
     }
 
diff --git a/crates/blockifier_reexecution/src/state_reader/utils.rs b/crates/blockifier_reexecution/src/state_reader/utils.rs
