committer: generate random state diff test util.

Author: yoavGrs

crates/starknet_committer/src/block_committer.rs

@@ -2,3 +2,4 @@ pub mod commit;
 pub mod errors;
 pub mod input;
 pub mod random_structs;
+pub mod state_diff_generator;

crates/starknet_committer/src/block_committer/random_structs.rs

@@ -6,7 +6,13 @@ use rand::prelude::IteratorRandom;
 use rand::Rng;
 use rand_distr::num_traits::ToPrimitive;
 use rand_distr::{Distribution, Geometric};
-use starknet_api::core::{ClassHash, ContractAddress, Nonce, PATRICIA_KEY_UPPER_BOUND};
+use starknet_api::core::{
+    ClassHash,
+    ContractAddress,
+    Nonce,
+    PatriciaKey,
+    PATRICIA_KEY_UPPER_BOUND,
+};
 use starknet_patricia::felt::u256_from_felt;
 use starknet_patricia::hash::hash_trait::HashOutput;
 use starknet_patricia::patricia_merkle_tree::external_test_utils::{
@@ -181,14 +187,20 @@ random_filled_node!(StarknetStorageValue);
 random_filled_node!(CompiledClassHash);
 random_filled_node!(ContractState);
 
-impl RandomValue for ContractAddress {
+impl RandomValue for PatriciaKey {
     fn random<R: Rng>(rng: &mut R, max: Option<U256>) -> Self {
-        let address_max = u256_from_felt(&Felt::from_hex_unchecked(PATRICIA_KEY_UPPER_BOUND));
-        let max = match max {
-            None => address_max,
-            Some(caller_max) => min(address_max, caller_max),
+        let upper_bound = u256_from_felt(&Felt::from_hex_unchecked(PATRICIA_KEY_UPPER_BOUND));
+        let max_patricia_key = match max {
+            None => upper_bound,
+            Some(caller_max) => min(upper_bound, caller_max),
         };
-        ContractAddress::try_from(Felt::random(rng, Some(max))).unwrap()
+        PatriciaKey::try_from(Felt::random(rng, Some(max_patricia_key))).unwrap()
+    }
+}
+
+impl RandomValue for ContractAddress {
+    fn random<R: Rng>(rng: &mut R, max: Option<U256>) -> Self {
+        ContractAddress(PatriciaKey::random(rng, max))
     }
 }
 

crates/starknet_committer/src/block_committer/state_diff_generator.rs

@@ -0,0 +1,40 @@
+use std::collections::HashMap;
+
+use rand::rngs::StdRng;
+use starknet_api::core::{ContractAddress, PatriciaKey};
+use starknet_api::state::StorageKey;
+
+use crate::block_committer::input::{StarknetStorageKey, StarknetStorageValue, StateDiff};
+use crate::block_committer::random_structs::RandomValue;
+
+#[cfg(test)]
+#[path = "state_diff_generator_test.rs"]
+pub mod state_diff_generator_test;
+
+pub(crate) const CONTRACT_ADDRESS: u32 = 500_u32;
+pub(crate) const N_STORAGE_UPDATES: usize = 1000_usize;
+
+pub fn generate_random_state_diff(rng: &mut StdRng) -> StateDiff {
+    let mut storage_updates = HashMap::new();
+    let mut contract_updates = HashMap::with_capacity(N_STORAGE_UPDATES);
+    for _ in 0..N_STORAGE_UPDATES {
+        let storage_entry = generate_random_storage_entry(rng);
+        contract_updates.insert(storage_entry.0, storage_entry.1);
+    }
+
+    storage_updates.insert(ContractAddress::from(CONTRACT_ADDRESS), contract_updates);
+    StateDiff {
+        address_to_class_hash: Default::default(),
+        address_to_nonce: Default::default(),
+        class_hash_to_compiled_class_hash: HashMap::new(),
+        storage_updates,
+    }
+}
+
+pub(crate) fn generate_random_storage_entry(
+    rng: &mut StdRng,
+) -> (StarknetStorageKey, StarknetStorageValue) {
+    let key = StarknetStorageKey(StorageKey(PatriciaKey::random(rng, None)));
+    let value = StarknetStorageValue::random(rng, None);
+    (key, value)
+}

crates/starknet_committer/src/block_committer/state_diff_generator_test.rs

@@ -0,0 +1,37 @@
+use std::collections::HashMap;
+
+use rand::rngs::StdRng;
+use rand::SeedableRng;
+use rstest::rstest;
+use starknet_api::core::ContractAddress;
+
+use crate::block_committer::state_diff_generator::{
+    generate_random_state_diff,
+    generate_random_storage_entry,
+    CONTRACT_ADDRESS,
+    N_STORAGE_UPDATES,
+};
+
+#[rstest]
+fn generate_random_state_diff_test() {
+    let seed = 42_u64; // Constant seed for reproducibility
+    let mut rng = StdRng::seed_from_u64(seed);
+    let state_diff = generate_random_state_diff(&mut rng);
+    let contract =
+        state_diff.storage_updates.get(&ContractAddress::from(CONTRACT_ADDRESS)).unwrap();
+    assert_eq!(contract.len(), N_STORAGE_UPDATES);
+}
+
+#[rstest]
+fn key_distribution_test() {
+    let seed = 42_u64; // Constant seed for reproducibility
+    let mut rng = StdRng::seed_from_u64(seed);
+
+    let n_iterations = N_STORAGE_UPDATES * 100;
+    let mut storage_updates = HashMap::with_capacity(n_iterations);
+    for _ in 0..n_iterations {
+        let (key, value) = generate_random_storage_entry(&mut rng);
+        storage_updates.insert(key, value);
+    }
+    assert!(storage_updates.len() >= (n_iterations * 99 / 100), "Key distribution is limited");
+}