Test for multiple writes/reads to the same storage slot (#2874)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #1559

## Introduced changes

<!-- A brief description of the changes -->
I  modified locally :
`storage_view` field  to map only StorageKey to felt

<details>
<summary>Screenshot of modified
`crates/runtime/src/starknet/state.rs`</summary>
<img
src="https://github.com/user-attachments/assets/6bcb98e5-9ccd-4064-a5af-56ea300a9c7d"
alt="state modified locally" </img>
</details>

And created two test cases which ensure that writes to the storage
across multiple contracts with same ClassHash and storage key is not
possible inside
[`crates/cheatnet/tests/cheatcodes/multiple_writes_same_storage.rs`](diffhunk://#diff-e17b72d677be53df13b4896cb6770dc9f012711c5f02ac3e6dd7f7238d8ef32fR1-R46):
* `same_storage_access_call_contract` - Verifies that the two deployed
contracts with same class_hash have different addresses and demonstrates
modification and access to storage variable `balance` with
`call_contract` method
* `same_storage_access_store` - does same routine but uses custom
implementations for storage operations `store` and `load` instead of
`call_contract` to access to storage
## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [ ] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [ ] Added changes to `CHANGELOG.md`

---------

Co-authored-by: Franciszek Job <[email protected]>

Author: beeguy74

crates/cheatnet/tests/cheatcodes/mod.rs

@@ -16,6 +16,7 @@ mod generate_random_felt;
 mod get_class_hash;
 mod load;
 mod mock_call;
+mod multiple_writes_same_storage;
 mod precalculate_address;
 mod replace_bytecode;
 mod spy_events;

crates/cheatnet/tests/cheatcodes/multiple_writes_same_storage.rs

@@ -0,0 +1,78 @@
+use crate::cheatcodes::variable_address;
+use crate::common::assertions::assert_success;
+use crate::common::get_contracts;
+use cheatnet::runtime_extensions::forge_runtime_extension::cheatcodes::storage::{load, store};
+use starknet_api::core::ContractAddress;
+use starknet_types_core::felt::Felt;
+
+use super::test_environment::TestEnvironment;
+
+trait StoreTrait {
+    fn store(&mut self, target: ContractAddress, storage_address: Felt, value: u128);
+    fn load(&mut self, target: ContractAddress, storage_address: Felt) -> Felt;
+}
+
+impl StoreTrait for TestEnvironment {
+    fn store(&mut self, target: ContractAddress, storage_address: Felt, value: u128) {
+        store(
+            &mut self.cached_state,
+            target,
+            storage_address,
+            Felt::from(value),
+        )
+        .unwrap();
+    }
+
+    fn load(&mut self, target: ContractAddress, storage_address: Felt) -> Felt {
+        load(&mut self.cached_state, target, storage_address).unwrap()
+    }
+}
+
+#[test]
+fn same_storage_access_call_contract() {
+    let mut test_env = TestEnvironment::new();
+    let contracts_data = get_contracts();
+    let hello_class_hash = test_env.declare("HelloStarknet", &contracts_data);
+    let contract_address_a = test_env.deploy_wrapper(&hello_class_hash, &[]);
+    let contract_address_b = test_env.deploy_wrapper(&hello_class_hash, &[]);
+    assert_ne!(contract_address_b, contract_address_a);
+
+    test_env.call_contract(&contract_address_a, "increase_balance", &[Felt::from(420)]);
+    let balance_value_a = test_env.call_contract(&contract_address_a, "get_balance", &[]);
+    assert_success(balance_value_a, &[Felt::from(420)]);
+
+    let balance_value_b = test_env.call_contract(&contract_address_b, "get_balance", &[]);
+    assert_success(balance_value_b, &[Felt::from(0)]);
+
+    test_env.call_contract(&contract_address_b, "increase_balance", &[Felt::from(42)]);
+
+    let balance_value_b = test_env.call_contract(&contract_address_b, "get_balance", &[]);
+    assert_success(balance_value_b, &[Felt::from(42)]);
+
+    let balance_value_a = test_env.call_contract(&contract_address_a, "get_balance", &[]);
+    assert_success(balance_value_a, &[Felt::from(420)]);
+}
+
+#[test]
+fn same_storage_access_store() {
+    let mut test_env = TestEnvironment::new();
+    let contracts_data = get_contracts();
+    let hello_class_hash = test_env.declare("HelloStarknet", &contracts_data);
+    let contract_address_a = test_env.deploy_wrapper(&hello_class_hash, &[]);
+    let contract_address_b = test_env.deploy_wrapper(&hello_class_hash, &[]);
+    assert_ne!(contract_address_b, contract_address_a);
+
+    test_env.store(contract_address_a, variable_address("balance"), 450);
+    let balance_value_a = test_env.load(contract_address_a, variable_address("balance"));
+    assert_eq!(balance_value_a, Felt::from(450));
+
+    let balance_value_b = test_env.load(contract_address_b, variable_address("balance"));
+    assert_eq!(balance_value_b, Felt::from(0));
+
+    test_env.store(contract_address_b, variable_address("balance"), 42);
+    let balance_value_b = test_env.load(contract_address_b, variable_address("balance"));
+    assert_eq!(balance_value_b, Felt::from(42));
+
+    let balance_value_a = test_env.load(contract_address_a, variable_address("balance"));
+    assert_eq!(balance_value_a, Felt::from(450));
+}