blockifier_reexecution: use StateReaderAndContractManager in reexecution crate

Author: Yonatan-Starkware

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

crates/blockifier_reexecution/src/main.rs

@@ -197,18 +197,19 @@ 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),
+                    Some(rpc_state_reader_config),
                     rpc_args.parse_chain_id(),
                     false,
-                ))
+                ), &contract_class_manager)
             })
             .await
             .unwrap();
@@ -227,6 +228,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 +239,7 @@ async fn main() {
                     node_url,
                     chain_id,
                     transaction_path,
+                    &contract_class_manager,
                 )
             })
             .await
@@ -251,10 +255,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 +274,7 @@ async fn main() {
                             full_file_path,
                             node_url,
                             chain_id,
+                            &contract_class_manager_shared,
                         )
                     })
                     .await
@@ -281,12 +290,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.");
                 });

crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs

@@ -7,11 +7,12 @@ use blockifier::blockifier_versioned_constants::VersionedConstants;
 use blockifier::bouncer::BouncerConfig;
 use blockifier::context::BlockContext;
 use blockifier::execution::contract_class::RunnableCompiledClass;
+use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::state::cached_state::{CommitmentStateDiff, StateMaps};
 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 +210,19 @@ 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 +261,14 @@ 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>> {
+        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)
+            .get_transaction_executor(self.block_context_next_block, transaction_executor_config, contract_class_manager)
     }
 
     fn get_next_block_txs(&self) -> ReexecutionResult<Vec<BlockifierTransaction>> {

crates/blockifier_reexecution/src/state_reader/reexecution_state_reader.rs

@@ -3,6 +3,7 @@ use blockifier::blockifier::config::TransactionExecutorConfig;
 use blockifier::blockifier::transaction_executor::TransactionExecutor;
 use blockifier::state::cached_state::CommitmentStateDiff;
 use blockifier::state::errors::StateError;
+use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::state::global_cache::CompiledClasses;
 use blockifier::state::state_api::{StateReader, StateResult};
 use blockifier::transaction::account_transaction::ExecutionFlags;
@@ -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>>;

crates/blockifier_reexecution/src/state_reader/test_state_reader.rs

@@ -11,13 +11,14 @@ use blockifier::blockifier::config::TransactionExecutorConfig;
 use blockifier::blockifier::transaction_executor::TransactionExecutor;
 use blockifier::blockifier_versioned_constants::VersionedConstants;
 use blockifier::bouncer::BouncerConfig;
+use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::context::BlockContext;
 use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::state::cached_state::CommitmentStateDiff;
 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 +286,19 @@ 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 +459,16 @@ 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,
         )
     }
 

crates/blockifier_reexecution/src/state_reader/utils.rs

@@ -7,6 +7,8 @@ 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::context::{ChainInfo, FeeTokenAddresses};
+use blockifier::state::contract_class_manager::ContractClassManager;
+use blockifier::blockifier::config::ContractClassManagerConfig;
 use blockifier::state::cached_state::{CachedState, CommitmentStateDiff, StateMaps};
 use blockifier::state::state_api::StateReader;
 use indexmap::IndexMap;
@@ -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,18 @@ 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();
+        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 +267,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 +278,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 +295,10 @@ 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 +321,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 +354,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);