blockifier_reexecution: use StateReaderAndContractManager in reexecution crate

Author: Yonatan-Starkware

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
@@ -16,7 +17,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", "testing"] }
 clap = { workspace = true, features = ["cargo", "derive"] }
 flate2.workspace = true
 google-cloud-storage.workspace = true

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,
@@ -57,17 +59,23 @@ 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 =
+                ContractClassManager::start(ContractClassManagerConfig::create_for_testing(
+                    cfg!(feature = "cairo_native"),
+                    cfg!(feature = "cairo_native"),
+                ));
 
             // 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 +100,23 @@ 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)
+            let contract_class_manager =
+                ContractClassManager::start(ContractClassManagerConfig::create_for_testing(
+                    cfg!(feature = "cairo_native"),
+                    cfg!(feature = "cairo_native"),
+                ));
+
+            // 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()
@@ -111,10 +131,18 @@ async fn main() {
             let block_numbers = parse_block_numbers_args(block_numbers);
             println!("Computing reexecution data for blocks {block_numbers:?}.");
 
+            let contract_class_manager =
+                ContractClassManager::start(ContractClassManagerConfig::create_for_testing(
+                    cfg!(feature = "cairo_native"),
+                    cfg!(feature = "cairo_native"),
+                ));
+
             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 = 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 +154,7 @@ async fn main() {
                             full_file_path,
                             node_url,
                             chain_id,
+                            contract_class_manager,
                         )
                     })
                     .await
@@ -141,12 +170,23 @@ async fn main() {
             let block_numbers = parse_block_numbers_args(block_numbers);
             println!("Reexecuting blocks {block_numbers:?}.");
 
+            let contract_class_manager =
+                ContractClassManager::start(ContractClassManagerConfig::create_for_testing(
+                    cfg!(feature = "cairo_native"),
+                    cfg!(feature = "cairo_native"),
+                ));
+
             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.");
                 });

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,18 @@ 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::new(self, contract_class_manager.clone(), None);
+        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 +241,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 +261,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>> {

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,26 @@ 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::create_for_testing(
+        cfg!(feature = "cairo_native"),
+        cfg!(feature = "cairo_native"),
+    ))
+}
+
 #[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.

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,18 @@ 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::new(self, contract_class_manager.clone(), None);
+        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 +403,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 +412,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 +428,7 @@ impl ConsecutiveTestStateReaders {
                 last_constructed_block_number.next().expect("Overflow in block number"),
                 dump_mode,
             ),
+            contract_class_manager,
         }
     }
 
@@ -457,14 +468,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,
         )
     }