starknet_os: aliases test

Author: nimrod-starkware

crates/starknet_os/src/aliases_test.rs

@@ -0,0 +1,92 @@
+use std::collections::HashMap;
+
+use blockifier::test_utils::dict_state_reader::DictStateReader;
+use cairo_vm::hint_processor::builtin_hint_processor::dict_hint_utils::DICT_ACCESS_SIZE;
+use cairo_vm::hint_processor::hint_processor_utils::felt_to_usize;
+use cairo_vm::types::builtin_name::BuiltinName;
+use rstest::rstest;
+use starknet_api::core::ContractAddress;
+use starknet_api::state::StorageKey;
+use starknet_types_core::felt::Felt;
+
+use crate::test_utils::cairo_runner::{
+    run_cairo_0_entry_point,
+    EndpointArg,
+    EntryPointRunnerConfig,
+    ImplicitArg,
+    PointerArg,
+    ValueArg,
+};
+
+#[rstest]
+#[case(Vec::new(), Vec::new(), HashMap::new())]
+fn allocate_and_replace_keys_from_empty_storage(
+    #[case] keys: Vec<Felt>,
+    #[case] expected_alias_per_key: Vec<Felt>,
+    #[case] expected_alias_storage: HashMap<Felt, Felt>,
+) {
+    let (actual_alias_storage, actual_alias_per_key) =
+        allocate_aliases_for_keys_and_replace(keys, HashMap::new());
+    assert_eq!(actual_alias_storage, expected_alias_storage);
+    assert_eq!(actual_alias_per_key, expected_alias_per_key);
+}
+
+fn allocate_aliases_for_keys_and_replace(
+    keys: Vec<Felt>,
+    initial_storage: HashMap<StorageKey, Felt>,
+) -> (HashMap<Felt, Felt>, Vec<Felt>) {
+    let runner_config = EntryPointRunnerConfig::default();
+    let entrypoint = "allocate_alias_for_keys_and_replace";
+    let program_str = "COMPLETE";
+    let implicit_args = vec![ImplicitArg::Builtin(BuiltinName::range_check)];
+    let expected_explicit_return_values = vec![
+        EndpointArg::Value(ValueArg::Single(Felt::ZERO)), // Aliases.len
+        EndpointArg::Pointer(PointerArg::Array(vec![ // Aliases.ptr
+            Felt::ZERO;
+            (keys.len() + 1) * DICT_ACCESS_SIZE
+            ])),
+        EndpointArg::Pointer(PointerArg::Array(vec![Felt::ZERO; keys.len()])),
+    ];
+    let n_keys_arg = EndpointArg::Value(ValueArg::Single(keys.len().into()));
+    let keys_arg = EndpointArg::Pointer(PointerArg::Array(keys));
+    let explicit_args = vec![n_keys_arg, keys_arg];
+    let alias_contract_address: ContractAddress = Felt::TWO.try_into().unwrap();
+    let storage_view = initial_storage
+        .into_iter()
+        .map(|(key, value)| ((alias_contract_address, key), value))
+        .collect();
+
+    let state_reader = DictStateReader { storage_view, ..Default::default() };
+    let (_, explicit_return_values, _) = run_cairo_0_entry_point(
+        &runner_config,
+        program_str,
+        entrypoint,
+        &explicit_args,
+        &implicit_args,
+        &expected_explicit_return_values,
+        HashMap::new(),
+        Some(state_reader),
+    )
+    .unwrap();
+    let mut actual_alias_storage = HashMap::new();
+    if let [
+        EndpointArg::Value(ValueArg::Single(n_aliases)),
+        EndpointArg::Value(ValueArg::Array(aliases_storage_updates)),
+        EndpointArg::Value(ValueArg::Array(alias_per_key)),
+    ] = explicit_return_values.as_slice()
+    {
+        let n_aliases = felt_to_usize(n_aliases).unwrap();
+        assert!(aliases_storage_updates.len() % DICT_ACCESS_SIZE == 0);
+        assert!(aliases_storage_updates.len() / DICT_ACCESS_SIZE == n_aliases);
+        let key_offset = 0;
+        let new_value_offset = 2;
+        for i in 0..n_aliases {
+            let key = aliases_storage_updates[i * DICT_ACCESS_SIZE + key_offset];
+            let new_value = aliases_storage_updates[i * DICT_ACCESS_SIZE + new_value_offset];
+            actual_alias_storage.insert(key, new_value);
+        }
+        (actual_alias_storage, alias_per_key.clone().to_vec())
+    } else {
+        panic!("The return value doesn't match the given format.");
+    }
+}

crates/starknet_os/src/lib.rs

@@ -1,3 +1,5 @@
+#[cfg(any(test, feature = "testing"))]
+pub mod aliases_test;
 pub mod errors;
 pub mod hint_processor;
 pub mod hints;

crates/starknet_os/src/test_utils/cairo_runner.rs

@@ -2,6 +2,7 @@ use std::any::Any;
 use std::collections::{HashMap, HashSet};
 
 use blockifier::blockifier_versioned_constants::VersionedConstants;
+use blockifier::test_utils::dict_state_reader::DictStateReader;
 use cairo_vm::serde::deserialize_program::Member;
 use cairo_vm::types::builtin_name::BuiltinName;
 use cairo_vm::types::layout_name::LayoutName;
@@ -553,6 +554,7 @@ fn get_return_values(
 /// Hint locals are added to the outermost exec scope.
 /// If the endpoint used builtins, the respective returned (implicit) arg is the builtin instance
 /// usage, unless the builtin is the output builtin, in which case the arg is the output.
+#[allow(clippy::too_many_arguments)]
 pub fn run_cairo_0_entry_point(
     runner_config: &EntryPointRunnerConfig,
     program_bytes: &[u8],
@@ -561,6 +563,7 @@ pub fn run_cairo_0_entry_point(
     implicit_args: &[ImplicitArg],
     expected_explicit_return_values: &[EndpointArg],
     hint_locals: HashMap<String, Box<dyn Any>>,
+    state_reader: Option<DictStateReader>,
 ) -> Cairo0EntryPointRunnerResult<(Vec<EndpointArg>, Vec<EndpointArg>, CairoRunner)> {
     let mut entrypoint = entrypoint.to_string();
     if runner_config.add_main_prefix_to_entrypoint {
@@ -571,7 +574,7 @@ pub fn run_cairo_0_entry_point(
     let program = inject_builtins(program_bytes, implicit_args)?;
     info!("Successfully injected builtins into program.");
 
-    let (state_reader, os_hints_config, os_state_input) = (None, None, None);
+    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,

crates/starknet_os/src/test_utils/utils.rs

@@ -38,6 +38,7 @@ pub fn run_cairo_function_and_check_result(
         implicit_args,
         expected_explicit_retdata,
         hint_locals,
+        None,
     )?;
     assert_eq!(expected_explicit_retdata, &actual_explicit_retdata);
     assert_eq!(expected_implicit_retdata, &actual_implicit_retdata);

crates/starknet_os/src/tests/bls_field.rs

@@ -155,6 +155,7 @@ fn test_horner_eval() {
             &implicit_args,
             &[EndpointArg::Value(ValueArg::Array(vec![Felt::ZERO, Felt::ZERO, Felt::ZERO]))],
             HashMap::new(),
+            None,
         )
         .unwrap();