blockifier_reexecution: use StateReaderAndContractManager in reexecution crate

Yonatan-Starkware · Yonatan-Starkware · commit b9385a5d6060 · 2025-11-26T09:52:13.000+02:00
diff --git a/crates/blockifier_reexecution/Cargo.toml b/crates/blockifier_reexecution/Cargo.toml
@@ -16,7 +16,7 @@ apollo_gateway_config.workspace = true
 apollo_rpc_execution.workspace = true
 apollo_sierra_compilation_config.workspace = true
 assert_matches.workspace = true
-blockifier = { workspace = true, features = ["reexecution"] }
+blockifier = { workspace = true, features = ["reexecution", "cairo_native"] }
 clap = { workspace = true, features = ["cargo", "derive"] }
 flate2.workspace = true
 google-cloud-storage.workspace = true
diff --git a/crates/blockifier_reexecution/src/main.rs b/crates/blockifier_reexecution/src/main.rs
@@ -1,10 +1,12 @@
 use std::fs;
 use std::path::Path;
+use std::sync::Arc;
 
 use apollo_gateway_config::config::RpcStateReaderConfig;
 use blockifier_reexecution::state_reader::offline_state_reader::OfflineConsecutiveStateReaders;
 use blockifier_reexecution::state_reader::test_state_reader::ConsecutiveTestStateReaders;
 use blockifier_reexecution::state_reader::utils::{
+    create_contract_class_manager,
     execute_single_transaction_from_json,
     get_block_numbers_for_reexecution,
     guess_chain_id_from_node_url,
@@ -197,18 +199,22 @@ async fn main() {
                 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());
+            let contract_class_manager = create_contract_class_manager();
 
             // 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),
-                    rpc_args.parse_chain_id(),
-                    false,
-                ))
+                reexecute_and_verify_correctness(
+                    ConsecutiveTestStateReaders::new(
+                        BlockNumber(block_number - 1),
+                        Some(rpc_state_reader_config),
+                        rpc_args.parse_chain_id(),
+                        false,
+                    ),
+                    &contract_class_manager,
+                )
             })
             .await
             .unwrap();
@@ -227,6 +233,8 @@ async fn main() {
 
             let (node_url, chain_id) = (rpc_args.node_url.clone(), rpc_args.parse_chain_id());
 
+            let contract_class_manager = create_contract_class_manager();
+
             // 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.
@@ -236,6 +244,7 @@ async fn main() {
                     node_url,
                     chain_id,
                     transaction_path,
+                    &contract_class_manager,
                 )
             })
             .await
@@ -251,10 +260,14 @@ async fn main() {
             let block_numbers = parse_block_numbers_args(block_numbers);
             println!("Computing reexecution data for blocks {block_numbers:?}.");
 
+            let contract_class_manager = Arc::new(create_contract_class_manager());
+
             let mut task_set = tokio::task::JoinSet::new();
             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_shared = Arc::clone(&contract_class_manager);
+
                 // 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.
@@ -266,6 +279,7 @@ async fn main() {
                             full_file_path,
                             node_url,
                             chain_id,
+                            &contract_class_manager_shared,
                         )
                     })
                     .await
@@ -281,12 +295,16 @@ async fn main() {
             let block_numbers = parse_block_numbers_args(block_numbers);
             println!("Reexecuting blocks {block_numbers:?}.");
 
+            let contract_class_manager = Arc::new(create_contract_class_manager());
+
             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_shared = Arc::clone(&contract_class_manager);
                 task_set.spawn(async move {
                     reexecute_and_verify_correctness(
                         OfflineConsecutiveStateReaders::new_from_file(&full_file_path).unwrap(),
+                        &contract_class_manager_shared,
                     );
                     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};
@@ -209,14 +213,20 @@ 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(
-            self,
+        let state_reader_and_contract_manager = StateReaderAndContractManager {
+            state_reader: self,
+            contract_class_manager: contract_class_manager.clone(),
+        };
+        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(),
@@ -255,13 +265,20 @@ impl OfflineConsecutiveStateReaders {
     }
 }
 
-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)
+        contract_class_manager: &ContractClassManager,
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<OfflineStateReader>>>
+    {
+        self.offline_state_reader_prev_block.get_transaction_executor(
+            self.block_context_next_block,
+            transaction_executor_config,
+            contract_class_manager,
+        )
     }
 
     fn get_next_block_txs(&self) -> ReexecutionResult<Vec<BlockifierTransaction>> {
diff --git a/crates/blockifier_reexecution/src/state_reader/reexecution_state_reader.rs b/crates/blockifier_reexecution/src/state_reader/reexecution_state_reader.rs
@@ -2,6 +2,7 @@ use apollo_rpc_execution::DEPRECATED_CONTRACT_SIERRA_SIZE;
 use blockifier::blockifier::config::TransactionExecutorConfig;
 use blockifier::blockifier::transaction_executor::TransactionExecutor;
 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};
@@ -131,6 +132,7 @@ pub trait ConsecutiveReexecutionStateReaders<S: StateReader> {
     fn pre_process_and_create_executor(
         self,
         transaction_executor_config: Option<TransactionExecutorConfig>,
+        contract_class_manager: &ContractClassManager,
     ) -> ReexecutionResult<TransactionExecutor<S>>;
 
     fn get_next_block_txs(&self) -> ReexecutionResult<Vec<BlockifierTransaction>>;
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};
@@ -285,14 +289,20 @@ 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(
-            self,
+        let state_reader_and_contract_manager = StateReaderAndContractManager {
+            state_reader: self,
+            contract_class_manager: contract_class_manager.clone(),
+        };
+        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(),
@@ -453,14 +463,19 @@ 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>> {
+        contract_class_manager: &ContractClassManager,
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<TestStateReader>>>
+    {
         self.last_block_state_reader.get_transaction_executor(
             self.next_block_state_reader.get_block_context()?,
             transaction_executor_config,
+            contract_class_manager,
         )
     }
 
diff --git a/crates/blockifier_reexecution/src/state_reader/utils.rs b/crates/blockifier_reexecution/src/state_reader/utils.rs
@@ -6,8 +6,10 @@ use std::sync::LazyLock;
 use apollo_gateway_config::config::RpcStateReaderConfig;
 use apollo_rpc_execution::{ETH_FEE_CONTRACT_ADDRESS, STRK_FEE_CONTRACT_ADDRESS};
 use assert_matches::assert_matches;
+use blockifier::blockifier::config::ContractClassManagerConfig;
 use blockifier::context::{ChainInfo, FeeTokenAddresses};
 use blockifier::state::cached_state::{CachedState, CommitmentStateDiff, StateMaps};
+use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::state::state_api::StateReader;
 use indexmap::IndexMap;
 use pretty_assertions::assert_eq;
@@ -39,6 +41,13 @@ pub static RPC_NODE_URL: LazyLock<String> = LazyLock::new(|| {
         .unwrap_or_else(|_| "https://free-rpc.nethermind.io/mainnet-juno/".to_string())
 });
 
+pub fn create_contract_class_manager() -> ContractClassManager {
+    let mut contract_class_manager_config = ContractClassManagerConfig::default();
+    contract_class_manager_config.cairo_native_run_config.run_cairo_native = true;
+    contract_class_manager_config.cairo_native_run_config.wait_on_native_compilation = true;
+    ContractClassManager::start(contract_class_manager_config)
+}
+
 pub fn guess_chain_id_from_node_url(node_url: &str) -> ReexecutionResult<ChainId> {
     match (
         node_url.contains("mainnet"),
@@ -223,17 +232,19 @@ impl From<CommitmentStateDiff> for ComparableStateDiff {
 }
 
 pub fn reexecute_and_verify_correctness<
-    S: StateReader + Send + Sync + Clone + 'static,
+    S: StateReader + Send + Sync + 'static,
     T: ConsecutiveReexecutionStateReaders<S>,
 >(
     consecutive_state_readers: T,
+    contract_class_manager: &ContractClassManager,
 ) -> Option<CachedState<S>> {
     let expected_state_diff = consecutive_state_readers.get_next_block_state_diff().unwrap();
 
     let all_txs_in_next_block = consecutive_state_readers.get_next_block_txs().unwrap();
 
-    let mut transaction_executor =
-        consecutive_state_readers.pre_process_and_create_executor(None).unwrap();
+    let mut transaction_executor = consecutive_state_readers
+        .pre_process_and_create_executor(None, contract_class_manager)
+        .unwrap();
 
     let execution_results = transaction_executor.execute_txs(&all_txs_in_next_block, None);
     // Verify all transactions executed successfully.
@@ -257,6 +268,7 @@ pub fn reexecute_block_for_testing(block_number: u64) {
 
     reexecute_and_verify_correctness(
         OfflineConsecutiveStateReaders::new_from_file(&full_file_path).unwrap(),
+        &create_contract_class_manager(),
     );
 
     println!("Reexecution test for block {block_number} passed successfully.");
@@ -267,6 +279,7 @@ pub fn write_block_reexecution_data_to_file(
     full_file_path: String,
     node_url: String,
     chain_id: ChainId,
+    contract_class_manager: &ContractClassManager,
 ) {
     let config = RpcStateReaderConfig::from_url(node_url);
 
@@ -283,10 +296,16 @@ pub fn write_block_reexecution_data_to_file(
     let old_block_hash = consecutive_state_readers.get_old_block_hash().unwrap();
 
     // Run the reexecution test and get the state maps and contract class mapping.
-    let block_state = reexecute_and_verify_correctness(consecutive_state_readers).unwrap();
+    let block_state =
+        reexecute_and_verify_correctness(consecutive_state_readers, contract_class_manager)
+            .unwrap();
     let serializable_data_prev_block = SerializableDataPrevBlock {
         state_maps: block_state.get_initial_reads().unwrap().into(),
-        contract_class_mapping: block_state.state.get_contract_class_mapping_dumper().unwrap(),
+        contract_class_mapping: block_state
+            .state
+            .state_reader
+            .get_contract_class_mapping_dumper()
+            .unwrap(),
     };
 
     // Write the reexecution data to a json file.
@@ -309,6 +328,7 @@ pub fn execute_single_transaction_from_json(
     node_url: String,
     chain_id: ChainId,
     transaction_json_path: String,
+    contract_class_manager: &ContractClassManager,
 ) -> ReexecutionResult<()> {
     // Load transaction from a JSON file.
     let json_content = read_to_string(&transaction_json_path).unwrap_or_else(|_| {
@@ -341,7 +361,7 @@ pub fn execute_single_transaction_from_json(
 
     // Create transaction executor.
     let mut transaction_executor =
-        consecutive_state_readers.pre_process_and_create_executor(None)?;
+        consecutive_state_readers.pre_process_and_create_executor(None, contract_class_manager)?;
 
     // Execute transaction (should be single element).
     let execution_results = transaction_executor.execute_txs(&blockifier_tx, None);
