starknet_os: fetch final HP state and use in test_revert

Author: dorimedini-starkware

crates/starknet_os/src/hints/hint_implementation/cairo1_revert/test.rs

@@ -4,6 +4,7 @@ use std::rc::Rc;
 use std::sync::LazyLock;
 
 use apollo_starknet_os_program::OS_PROGRAM_BYTES;
+use blockifier::state::state_api::StateReader;
 use cairo_vm::hint_processor::builtin_hint_processor::dict_manager::DictManager;
 use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::insert_value_into_ap;
 use cairo_vm::types::layout_name::LayoutName;
@@ -150,7 +151,7 @@ fn test_revert(#[case] test_vector: Vec<Operation>) {
     )))];
     let state_reader = None;
     let expected_explicit_return_values = vec![];
-    let (implicit_return_values, _explicit_return_values) = run_cairo_0_entrypoint(
+    let (implicit_return_values, _explicit_return_values, hint_processor) = run_cairo_0_entrypoint(
         entrypoint,
         &explicit_args,
         &implicit_args,
@@ -182,6 +183,11 @@ fn test_revert(#[case] test_vector: Vec<Operation>) {
         HashSet::from_iter(actual_contract_changes.keys().map(|address| ***address)),
         contract_addresses
     );
+    let final_hint_processor_state = &hint_processor
+        .execution_helpers_manager
+        .get_current_execution_helper()
+        .unwrap()
+        .cached_state;
     for (contract_address, contract_change) in actual_contract_changes.iter() {
         // Iterate over all storage changes for the contract address and verify that each change is
         // as expected.
@@ -192,9 +198,12 @@ fn test_revert(#[case] test_vector: Vec<Operation>) {
             let expected_value = expected_contract_storage.get(&full_contract_change.key).unwrap();
             assert_eq!(full_contract_change.prev_value, Felt::ZERO);
             assert_eq!(full_contract_change.new_value, *expected_value);
-            // TODO(Dori): If and when we get access to the final state of the hint processor,
-            //   verify that the current state in the execution helper for this contract address
-            //   and storage key is as expected.
+            assert_eq!(
+                final_hint_processor_state
+                    .get_storage_at(*contract_address, full_contract_change.key)
+                    .unwrap(),
+                *expected_value
+            );
         }
 
         // Verify class hashes.

crates/starknet_os/src/hints/hint_implementation/compiled_class/compiled_class_test.rs

@@ -324,16 +324,17 @@ fn run_compiled_class_hash_entry_point(
     // Run the Cairo entrypoint function.
     // State reader is not used in this test.
     let state_reader = None;
-    let (_implicit_return_values, explicit_return_values) = run_cairo_0_entrypoint(
-        entrypoint,
-        &explicit_args,
-        &implicit_args,
-        state_reader,
-        &mut runner,
-        &program,
-        &runner_config,
-        &expected_return_values,
-    )?;
+    let (_implicit_return_values, explicit_return_values, _hint_processor) =
+        run_cairo_0_entrypoint(
+            entrypoint,
+            &explicit_args,
+            &implicit_args,
+            state_reader,
+            &mut runner,
+            &program,
+            &runner_config,
+            &expected_return_values,
+        )?;
 
     // Get the actual execution resources, and compare with expected values.
     let actual_execution_resources = runner.get_execution_resources().unwrap();

crates/starknet_os/src/hints/hint_implementation/state_diff_encryption/state_diff_encryption_test.rs

@@ -153,17 +153,18 @@ fn test_state_diff_encryption_function(
     ];
     let state_reader = None;
     let expected_explicit_return_values: Vec<EndpointArg> = vec![];
-    let (implicit_return_values, _explicit_return_values) = run_cairo_0_entrypoint(
-        entrypoint,
-        &explicit_args,
-        &implicit_args,
-        state_reader,
-        &mut runner,
-        &program,
-        &runner_config,
-        &expected_explicit_return_values,
-    )
-    .unwrap();
+    let (implicit_return_values, _explicit_return_values, _hint_processor) =
+        run_cairo_0_entrypoint(
+            entrypoint,
+            &explicit_args,
+            &implicit_args,
+            state_reader,
+            &mut runner,
+            &program,
+            &runner_config,
+            &expected_explicit_return_values,
+        )
+        .unwrap();
     // [range_check_ptr, encrypted_dst_end]
     assert_eq!(implicit_return_values.len(), 2);
     let EndpointArg::Value(ValueArg::Single(MaybeRelocatable::RelocatableValue(encrypted_dst_end))) =
@@ -257,17 +258,18 @@ fn test_compute_public_keys_function(#[case] seed: u64, #[case] num_committee_me
     ];
     let state_reader = None;
     let expected_explicit_return_values: Vec<EndpointArg> = vec![];
-    let (implicit_return_values, _explicit_return_values) = run_cairo_0_entrypoint(
-        entrypoint,
-        &explicit_args,
-        &implicit_args,
-        state_reader,
-        &mut runner,
-        &program,
-        &runner_config,
-        &expected_explicit_return_values,
-    )
-    .unwrap();
+    let (implicit_return_values, _explicit_return_values, _hint_processor) =
+        run_cairo_0_entrypoint(
+            entrypoint,
+            &explicit_args,
+            &implicit_args,
+            state_reader,
+            &mut runner,
+            &program,
+            &runner_config,
+            &expected_explicit_return_values,
+        )
+        .unwrap();
 
     // [range_check_ptr, ec_op_ptr, encrypted_dst_end]
     assert_eq!(implicit_return_values.len(), 3);
@@ -357,17 +359,18 @@ fn test_symmetric_key_encryption_function(#[case] seed: u64, #[case] num_committ
 
     let state_reader = None;
     let expected_explicit_return_values: Vec<EndpointArg> = vec![];
-    let (implicit_return_values, _explicit_return_values) = run_cairo_0_entrypoint(
-        entrypoint,
-        &explicit_args,
-        &implicit_args,
-        state_reader,
-        &mut runner,
-        &program,
-        &runner_config,
-        &expected_explicit_return_values,
-    )
-    .unwrap();
+    let (implicit_return_values, _explicit_return_values, _hint_processor) =
+        run_cairo_0_entrypoint(
+            entrypoint,
+            &explicit_args,
+            &implicit_args,
+            state_reader,
+            &mut runner,
+            &program,
+            &runner_config,
+            &expected_explicit_return_values,
+        )
+        .unwrap();
 
     // [range_check_ptr, ec_op_ptr, encrypted_dst_end]
     assert_eq!(implicit_return_values.len(), 3);

crates/starknet_os/src/hints/hint_implementation/stateful_compression/tests.rs

@@ -529,17 +529,18 @@ fn test_allocate_addresses_for_state_diff_and_replace(
     ];
 
     // Run the entrypoint with validations on the explicit & implicit args.
-    let (_, explicit_return_values) = run_cairo_0_entrypoint(
-        entrypoint,
-        &explicit_args,
-        &implicit_args,
-        Some(state_reader),
-        &mut cairo_runner,
-        &program,
-        &runner_config,
-        &expected_explicit_return_values,
-    )
-    .unwrap();
+    let (_implicit_return_values, explicit_return_values, _hint_processor) =
+        run_cairo_0_entrypoint(
+            entrypoint,
+            &explicit_args,
+            &implicit_args,
+            Some(state_reader),
+            &mut cairo_runner,
+            &program,
+            &runner_config,
+            &expected_explicit_return_values,
+        )
+        .unwrap();
 
     let [
         EndpointArg::Pointer(PointerArg::Array(aliases_storage_updates)),

crates/starknet_os/src/test_utils/cairo_runner.rs

@@ -1,5 +1,6 @@
 use std::any::Any;
 use std::collections::{HashMap, HashSet};
+use std::sync::LazyLock;
 
 use blockifier::blockifier_versioned_constants::VersionedConstants;
 use blockifier::test_utils::dict_state_reader::DictStateReader;
@@ -33,6 +34,8 @@ pub type Cairo0EntryPointRunnerResult<T> = Result<T, Cairo0EntryPointRunnerError
 #[path = "cairo_runner_test.rs"]
 mod test;
 
+pub static EMPTY_BLOCK_INPUT: LazyLock<OsBlockInput> = LazyLock::new(|| OsBlockInput::default());
+
 /// An arg passed by value (i.e., a felt, tuple, named tuple or struct).
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ValueArg {
@@ -592,7 +595,7 @@ pub fn initialize_and_run_cairo_0_entry_point(
         implicit_args,
         hint_locals,
     )?;
-    let (explicit_return_values, implicit_return_values) = run_cairo_0_entrypoint(
+    let (explicit_return_values, implicit_return_values, _hint_processor) = run_cairo_0_entrypoint(
         entrypoint,
         explicit_args,
         implicit_args,
@@ -643,17 +646,23 @@ pub fn initialize_cairo_runner(
     Ok((cairo_runner, program, entrypoint))
 }
 
+/// Runs a Cairo0 entry point.
+/// Returns the implicit and explicit return values, and the final state of the hint processor.
 #[allow(clippy::too_many_arguments)]
-pub fn run_cairo_0_entrypoint(
+pub fn run_cairo_0_entrypoint<'a>(
     entrypoint: String,
     explicit_args: &[EndpointArg],
     implicit_args: &[ImplicitArg],
     state_reader: Option<DictStateReader>,
     cairo_runner: &mut CairoRunner,
-    program: &Program,
+    program: &'a Program,
     runner_config: &EntryPointRunnerConfig,
     expected_explicit_return_values: &[EndpointArg],
-) -> Cairo0EntryPointRunnerResult<(Vec<EndpointArg>, Vec<EndpointArg>)> {
+) -> Cairo0EntryPointRunnerResult<(
+    Vec<EndpointArg>,
+    Vec<EndpointArg>,
+    SnosHintProcessor<'a, DictStateReader>,
+)> {
     // TODO(Amos): Perform complete validations.
     perform_basic_validations_on_explicit_args(explicit_args, program, &entrypoint)?;
     perform_basic_validations_on_implicit_args(implicit_args, program, &entrypoint)?;
@@ -667,12 +676,11 @@ pub fn run_cairo_0_entrypoint(
     info!("Converted explicit & implicit args to Cairo args.");
 
     let (os_hints_config, os_state_input) = (None, None);
-    let os_block_input = OsBlockInput::default();
     let mut hint_processor = SnosHintProcessor::new_for_testing(
         state_reader,
         program,
         os_hints_config,
-        &os_block_input,
+        &*EMPTY_BLOCK_INPUT,
         os_state_input,
     )
     .unwrap_or_else(|err| panic!("Failed to create SnosHintProcessor: {err:?}"));
@@ -700,5 +708,5 @@ pub fn run_cairo_0_entrypoint(
     info!("Successfully finished running entrypoint {entrypoint}");
     let (implicit_return_values, explicit_return_values) =
         get_return_values(implicit_args, expected_explicit_return_values, &cairo_runner.vm)?;
-    Ok((implicit_return_values, explicit_return_values))
+    Ok((implicit_return_values, explicit_return_values, hint_processor))
 }