blockifier: add unit test to state_reader_and_contract_manager's caching

Author: ArniStarkware

crates/apollo_gateway/src/state_reader_test.rs

@@ -421,8 +421,8 @@ async fn test_get_class_hash_at() {
     assert_eq!(result, expected_result);
 }
 
-// TODO(Arni): Check if any test cases here should move to the tests of
-// `StateReaderAndContractManager`.
+// TODO(Arni): Convert scenarios that are covered in the blockifier's
+// state_reader_and_contract_manager_test.rs to unit tests of sync_state_reader.
 #[rstest]
 #[case::cairo_0_declared_and_cached(
     cairo_0_declared_scenario(),

crates/blockifier/src/state.rs

@@ -11,6 +11,8 @@ pub mod state_api;
 #[cfg(any(feature = "testing", test))]
 pub mod state_api_test_utils;
 pub mod state_reader_and_contract_manager;
+#[cfg(any(feature = "testing", test))]
+pub mod state_reader_and_contract_manager_test_utils;
 pub mod stateful_compression;
 #[cfg(any(feature = "testing", test))]
 pub mod stateful_compression_test_utils;

crates/blockifier/src/state/global_cache.rs

@@ -36,6 +36,21 @@ impl CompiledClasses {
             },
         }
     }
+
+    // Note: For Cairo 1 classes, the Sierra does not match the Casm.
+    #[cfg(any(feature = "testing", test))]
+    pub fn from_runnable_for_testing(runnable_compiled_class: RunnableCompiledClass) -> Self {
+        match runnable_compiled_class {
+            RunnableCompiledClass::V0(compiled_class_v0) => Self::V0(compiled_class_v0),
+            RunnableCompiledClass::V1(compiled_class_v1) => {
+                Self::V1(compiled_class_v1, Arc::new(SierraContractClass::default()))
+            }
+            #[cfg(feature = "cairo_native")]
+            RunnableCompiledClass::V1Native(native_compiled_class_v1) => {
+                Self::V1Native(CachedCairoNative::Compiled(native_compiled_class_v1))
+            }
+        }
+    }
 }
 
 pub type RawClassCache = GlobalContractCache<CompiledClasses>;

crates/blockifier/src/state/state_reader_and_contract_manager.rs

@@ -7,6 +7,7 @@ use crate::state::contract_class_manager::ContractClassManager;
 use crate::state::errors::StateError;
 use crate::state::global_cache::CompiledClasses;
 use crate::state::state_api::{StateReader, StateResult};
+
 #[cfg(test)]
 #[path = "state_reader_and_contract_manager_test.rs"]
 pub mod state_reader_and_contract_manager_test;

crates/blockifier/src/state/state_reader_and_contract_manager_test.rs

@@ -1,20 +1,30 @@
+use std::sync::LazyLock;
+
 use assert_matches::assert_matches;
 use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::contracts::FeatureContract;
 use rstest::rstest;
+use starknet_api::class_hash;
 use starknet_api::contract_class::compiled_class_hash::HashVersion;
+use starknet_api::core::ClassHash;
 
-use crate::blockifier::config::ContractClassManagerConfig;
+use crate::blockifier::config::{CairoNativeRunConfig, ContractClassManagerConfig};
 use crate::execution::contract_class::RunnableCompiledClass;
 use crate::state::contract_class_manager::ContractClassManager;
+use crate::state::errors::StateError;
 #[cfg(feature = "cairo_native")]
-use crate::state::global_cache::{CachedCairoNative, CompiledClasses};
-use crate::state::state_api::StateReader;
+use crate::state::global_cache::CachedCairoNative;
+use crate::state::global_cache::CompiledClasses;
+use crate::state::state_api::{StateReader, StateResult};
+use crate::state::state_api_test_utils::assert_eq_state_result;
 use crate::state::state_reader_and_contract_manager::StateReaderAndContractManager;
+use crate::state::state_reader_and_contract_manager_test_utils::MockFetchCompiledClasses;
 use crate::test_utils::contracts::{FeatureContractData, FeatureContractTrait};
 use crate::test_utils::dict_state_reader::DictStateReader;
 use crate::test_utils::initial_test_state::state_reader_and_contract_manager_for_testing;
 
+static DUMMY_CLASS_HASH: LazyLock<ClassHash> = LazyLock::new(|| class_hash!(2_u32));
+
 fn build_reader_and_declare_contract(
     contract: FeatureContractData,
     contract_manager_config: ContractClassManagerConfig,
@@ -115,3 +125,146 @@ fn test_get_compiled_class_when_native_is_cached() {
     let compiled_class = state_reader.get_compiled_class(test_class_hash).unwrap();
     assert_matches!(compiled_class, RunnableCompiledClass::V1Native(_));
 }
+
+struct GetCompiledClassTestScenario {
+    expectations: GetCompiledClassTestExpectation,
+
+    // Test result.
+    expected_result: StateResult<RunnableCompiledClass>,
+}
+
+struct GetCompiledClassTestExpectation {
+    get_compiled_classes_result: Option<StateResult<CompiledClasses>>,
+    is_declared_result: Option<StateResult<bool>>,
+}
+
+fn add_expectation_to_mock_fetch_compiled_classes(
+    mock_fetch_compiled_classes: &mut MockFetchCompiledClasses,
+    expectations: GetCompiledClassTestExpectation,
+) {
+    if let Some(get_compiled_classes_result) = expectations.get_compiled_classes_result {
+        mock_fetch_compiled_classes
+            .expect_get_compiled_classes()
+            .times(1)
+            .return_once(move |_| get_compiled_classes_result);
+    }
+
+    if let Some(is_declared_result) = expectations.is_declared_result {
+        mock_fetch_compiled_classes
+            .expect_is_declared()
+            .times(1)
+            .return_once(|_| is_declared_result);
+    }
+}
+
+fn cairo_1_declared_scenario() -> GetCompiledClassTestScenario {
+    GetCompiledClassTestScenario {
+        expectations: GetCompiledClassTestExpectation {
+            get_compiled_classes_result: Some(Ok(CompiledClasses::from_runnable_for_testing(
+                RunnableCompiledClass::test_casm_contract_class(),
+            ))),
+            is_declared_result: None,
+        },
+        expected_result: Ok(RunnableCompiledClass::test_casm_contract_class()),
+    }
+}
+
+fn cairo_1_cached_scenario() -> GetCompiledClassTestScenario {
+    GetCompiledClassTestScenario {
+        expectations: GetCompiledClassTestExpectation {
+            get_compiled_classes_result: None,
+            is_declared_result: Some(Ok(true)), // Verification call for cached Cairo1 class.
+        },
+        expected_result: Ok(RunnableCompiledClass::test_casm_contract_class()),
+    }
+}
+
+fn cached_but_verification_failed_after_reorg_scenario() -> GetCompiledClassTestScenario {
+    GetCompiledClassTestScenario {
+        expectations: GetCompiledClassTestExpectation {
+            get_compiled_classes_result: None,
+            is_declared_result: Some(Ok(false)), // Verification fails after reorg.
+        },
+        expected_result: Err(StateError::UndeclaredClassHash(*DUMMY_CLASS_HASH)),
+    }
+}
+
+fn cairo_0_declared_scenario() -> GetCompiledClassTestScenario {
+    GetCompiledClassTestScenario {
+        expectations: GetCompiledClassTestExpectation {
+            get_compiled_classes_result: Some(Ok(CompiledClasses::from_runnable_for_testing(
+                RunnableCompiledClass::test_deprecated_casm_contract_class(),
+            ))),
+            is_declared_result: None,
+        },
+        expected_result: Ok(RunnableCompiledClass::test_deprecated_casm_contract_class()),
+    }
+}
+
+fn cairo_0_cached_scenario() -> GetCompiledClassTestScenario {
+    GetCompiledClassTestScenario {
+        expectations: GetCompiledClassTestExpectation {
+            get_compiled_classes_result: None,
+            is_declared_result: None,
+        },
+        expected_result: Ok(RunnableCompiledClass::test_deprecated_casm_contract_class()),
+    }
+}
+
+fn not_declared_scenario() -> GetCompiledClassTestScenario {
+    GetCompiledClassTestScenario {
+        expectations: GetCompiledClassTestExpectation {
+            get_compiled_classes_result: Some(Err(StateError::UndeclaredClassHash(
+                *DUMMY_CLASS_HASH,
+            ))),
+            is_declared_result: None,
+        },
+        expected_result: Err(StateError::UndeclaredClassHash(*DUMMY_CLASS_HASH)),
+    }
+}
+
+#[rstest]
+#[case::cairo_0_declared_and_cached(cairo_0_declared_scenario(), cairo_0_cached_scenario())]
+#[case::cairo_1_declared_and_cached(cairo_1_declared_scenario(), cairo_1_cached_scenario())]
+#[case::cairo_1_declared_then_verification_failed_after_reorg(
+    cairo_1_declared_scenario(),
+    cached_but_verification_failed_after_reorg_scenario()
+)]
+#[case::not_declared_then_declared(not_declared_scenario(), cairo_1_declared_scenario())]
+#[case::not_declared_both_rounds(not_declared_scenario(), not_declared_scenario())]
+fn test_get_compiled_class_caching_scenarios(
+    #[case] first_scenario: GetCompiledClassTestScenario,
+    #[case] second_scenario: GetCompiledClassTestScenario,
+) {
+    let contract_class_manager = ContractClassManager::start(ContractClassManagerConfig {
+        cairo_native_run_config: CairoNativeRunConfig {
+            wait_on_native_compilation: false,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+    let class_hash = *DUMMY_CLASS_HASH;
+
+    // First execution.
+    let mut first_reader = MockFetchCompiledClasses::new();
+    add_expectation_to_mock_fetch_compiled_classes(&mut first_reader, first_scenario.expectations);
+    let first_state_reader_and_manager =
+        state_reader_and_contract_manager_for_testing(first_reader, contract_class_manager.clone());
+
+    let first_result = first_state_reader_and_manager.get_compiled_class(class_hash);
+
+    // Second execution.
+    let mut second_reader = MockFetchCompiledClasses::new();
+    add_expectation_to_mock_fetch_compiled_classes(
+        &mut second_reader,
+        second_scenario.expectations,
+    );
+    let second_state_reader_and_manager =
+        state_reader_and_contract_manager_for_testing(second_reader, contract_class_manager);
+
+    let second_result = second_state_reader_and_manager.get_compiled_class(class_hash);
+
+    // Verify results.
+    assert_eq_state_result(&first_result, &first_scenario.expected_result);
+    assert_eq_state_result(&second_result, &second_scenario.expected_result);
+}

crates/blockifier/src/state/state_reader_and_contract_manager_test_utils.rs

@@ -0,0 +1,34 @@
+use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
+use starknet_api::state::StorageKey;
+use starknet_types_core::felt::Felt;
+
+use crate::execution::contract_class::RunnableCompiledClass;
+use crate::state::global_cache::CompiledClasses;
+use crate::state::state_api::{StateReader, StateResult};
+use crate::state::state_reader_and_contract_manager::FetchCompiledClasses as FetchCompiledClassesTrait;
+
+mockall::mock! {
+    pub FetchCompiledClasses {}
+
+    impl StateReader for FetchCompiledClasses {
+        fn get_storage_at(
+            &self,
+            contract_address: ContractAddress,
+            key: StorageKey,
+        ) -> StateResult<Felt>;
+
+        fn get_nonce_at(&self, contract_address: ContractAddress) -> StateResult<Nonce>;
+
+        fn get_class_hash_at(&self, contract_address: ContractAddress) -> StateResult<ClassHash>;
+
+        fn get_compiled_class(&self, class_hash: ClassHash) -> StateResult<RunnableCompiledClass>;
+
+        fn get_compiled_class_hash(&self, class_hash: ClassHash) -> StateResult<CompiledClassHash>;
+    }
+
+    // Implement FetchCompiledClasses methods
+    impl FetchCompiledClassesTrait for FetchCompiledClasses {
+        fn get_compiled_classes(&self, class_hash: ClassHash) -> StateResult<CompiledClasses>;
+        fn is_declared(&self, class_hash: ClassHash) -> StateResult<bool>;
+    }
+}