another opt

Author: edg-l

src/state/mod.rs

@@ -191,23 +191,22 @@ impl StateDiff {
 
         let mut storage_updates = HashMap::new();
 
-        let addresses: Vec<Address> =
-            get_keys(self.storage_updates.clone(), other.storage_updates.clone());
+        let addresses: Vec<&Address> = get_keys(&self.storage_updates, &other.storage_updates);
 
         for address in addresses {
             let default: HashMap<Felt252, Felt252> = HashMap::new();
             let mut map_a = self
                 .storage_updates
-                .get(&address)
+                .get(address)
                 .unwrap_or(&default)
                 .to_owned();
             let map_b = other
                 .storage_updates
-                .get(&address)
+                .get(address)
                 .unwrap_or(&default)
                 .to_owned();
             map_a.extend(map_b);
-            storage_updates.insert(address, map_a.clone());
+            storage_updates.insert(address.clone(), map_a.clone());
         }
 
         StateDiff {

src/utils.rs

@@ -279,12 +279,12 @@ pub fn to_cache_state_storage_mapping(
 
 // get a vector of keys from two hashmaps
 
-pub fn get_keys<K, V>(map_a: HashMap<K, V>, map_b: HashMap<K, V>) -> Vec<K>
+pub fn get_keys<'a, K, V>(map_a: &'a HashMap<K, V>, map_b: &'a HashMap<K, V>) -> Vec<&'a K>
 where
     K: Hash + Eq,
 {
-    let mut keys1: HashSet<K> = map_a.into_keys().collect();
-    let keys2: HashSet<K> = map_b.into_keys().collect();
+    let mut keys1: HashSet<&K> = map_a.keys().collect();
+    let keys2: HashSet<&K> = map_b.keys().collect();
 
     keys1.extend(keys2);