Raise error in interact_with_state if address not exists

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/cheated_syscalls.rs

@@ -257,7 +257,7 @@ pub fn storage_read(
     _remaining_gas: &mut u64,
 ) -> SyscallResult<StorageReadResponse> {
     let original_storage_address = syscall_handler.base.call.storage_address;
-    maybe_modify_storage_address(syscall_handler, cheatnet_state);
+    maybe_modify_storage_address(syscall_handler, cheatnet_state)?;
 
     let value = syscall_handler
         .base
@@ -282,7 +282,7 @@ pub fn storage_write(
     _remaining_gas: &mut u64,
 ) -> SyscallResult<StorageWriteResponse> {
     let original_storage_address = syscall_handler.base.call.storage_address;
-    maybe_modify_storage_address(syscall_handler, cheatnet_state);
+    maybe_modify_storage_address(syscall_handler, cheatnet_state)?;
 
     syscall_handler
         .base
@@ -303,19 +303,33 @@ pub fn storage_write(
 fn maybe_modify_storage_address(
     syscall_handler: &mut SyscallHintProcessor<'_>,
     cheatnet_state: &mut CheatnetState,
-) {
+) -> Result<(), StateError> {
     let contract_address = syscall_handler.storage_address();
     let test_address =
         TryFromHexStr::try_from_hex_str(TEST_ADDRESS).expect("Failed to parse `TEST_ADDRESS`");
 
     if contract_address != test_address {
-        return;
+        return Ok(());
     }
 
     let cheated_data = cheatnet_state.get_cheated_data(contract_address);
     if let Some(actual_address) = cheated_data.contract_address {
+        let class_hash = syscall_handler
+            .base
+            .state
+            .get_class_hash_at(actual_address)
+            .expect("`get_class_hash_at` should never fail");
+
+        if class_hash == ClassHash::default() {
+            return Err(StateError::StateReadError(format!(
+                "Failed to interact with contract state because no contract is deployed at address {actual_address}"
+            )));
+        }
+
         syscall_handler.base.call.storage_address = actual_address;
     }
+
+    Ok(())
 }
 
 #[derive(Debug)]

crates/forge/tests/integration/interact_with_state.rs

@@ -1,6 +1,6 @@
 use forge_runner::forge_config::ForgeTrackedResource;
 use indoc::indoc;
-use test_utils::runner::{Contract, assert_passed};
+use test_utils::runner::{Contract, assert_case_output_contains, assert_failed, assert_passed};
 use test_utils::running_tests::run_test_case;
 use test_utils::test_case;
 
@@ -82,3 +82,40 @@ fn get_contract_address_in_interact_with_state() {
 
     assert_passed(&result);
 }
+
+#[test]
+fn raise_error_if_non_existent_address() {
+    let test = test_case!(indoc!(
+        r"
+        use snforge_std::interact_with_state;
+
+        #[starknet::contract]
+        mod SingleFelt {
+            #[storage]
+            pub struct Storage {
+                pub field: felt252,
+            }
+        }
+
+        #[test]
+        fn test_single_felt() {
+            interact_with_state(
+                0x123.try_into().unwrap(),
+                || {
+                    let mut state = SingleFelt::contract_state_for_testing();
+                    state.field.write(1);
+                },
+            )
+        }
+            "
+    ));
+
+    let result = run_test_case(&test, ForgeTrackedResource::CairoSteps);
+
+    assert_failed(&result);
+    assert_case_output_contains(
+        &result,
+        "test_single_felt",
+        "Failed to interact with contract state because no contract is deployed at address 0x0000000000000000000000000000000000000000000000000000000000000123",
+    );
+}