Refactor snforge_std - typed_checked_cheatcode (#2833)

<!-- Reference any GitHub issues resolved by this PR -->
I am happy to announce the first pr from our mailing list! 🔥🔥
Thanks Peter for your contribution

## Introduced changes

<!-- A brief description of the changes -->

-

## Checklist

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

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

Author: kkawula

snforge_std/src/_cheatcode.cairo

@@ -1,29 +1,32 @@
-use core::option::OptionTrait;
-use core::array::ArrayTrait;
-use core::traits::Into;
-use core::array::SpanTrait;
+pub(crate) fn execute_cheatcode<const selector: felt252>(input: Span<felt252>) -> Span<felt252> {
+    let result = starknet::testing::cheatcode::<selector>(input);
+    let enum_variant = *result.at(0);
+    let result_content = result.slice(1, result.len() - 1);
 
-pub(crate) fn handle_cheatcode(input: Span<felt252>) -> Span<felt252> {
-    let first = *input.at(0);
-    let input = input.slice(1, input.len() - 1);
-
-    if first == 1 {
+    if enum_variant == 1 { // Check if the result is an `Err`
         let mut arr = array![core::byte_array::BYTE_ARRAY_MAGIC];
 
-        arr.append_span(input);
+        arr.append_span(result_content);
 
         panic(arr)
     } else {
-        input
+        result_content
+    }
+}
+
+pub(crate) fn execute_cheatcode_and_deserialize<const selector: felt252, T, +Serde<T>>(
+    input: Span<felt252>
+) -> T {
+    let mut serialized_output = execute_cheatcode::<selector>(input);
+
+    match Serde::deserialize(ref serialized_output) {
+        Option::Some(output) => output,
+        Option::None => panic!("snforge_std version mismatch: check the warning above")
     }
 }
 
 // Do not use this function directly.
 // It is an internal part of the snforge architecture used by macros.
 pub fn _is_config_run() -> bool {
-    let mut res = handle_cheatcode(
-        starknet::testing::cheatcode::<'is_config_mode'>(array![].span())
-    );
-
-    Serde::deserialize(ref res).unwrap_or(false)
+    execute_cheatcode_and_deserialize::<'is_config_mode'>(array![].span())
 }

snforge_std/src/byte_array.cairo

@@ -1,4 +1,3 @@
-use core::option::OptionTrait;
 use core::byte_array::BYTE_ARRAY_MAGIC;
 
 pub fn byte_array_as_felt_array(self: @ByteArray) -> Array<felt252> {

snforge_std/src/cheatcodes.cairo

@@ -1,6 +1,5 @@
 use starknet::{ContractAddress, ClassHash, contract_address_const};
-use starknet::testing::cheatcode;
-use super::_cheatcode::handle_cheatcode;
+use super::_cheatcode::execute_cheatcode_and_deserialize;
 
 pub mod events;
 pub mod l1_handler;
@@ -58,7 +57,7 @@ pub fn mock_call<T, impl TSerde: core::serde::Serde<T>, impl TDestruct: Destruct
 
     ret_data_arr.serialize(ref inputs);
 
-    handle_cheatcode(cheatcode::<'mock_call'>(inputs.span()));
+    execute_cheatcode_and_deserialize::<'mock_call', ()>(inputs.span());
 }
 
 
@@ -81,7 +80,7 @@ pub fn start_mock_call<T, impl TSerde: core::serde::Serde<T>, impl TDestruct: De
 
     ret_data_arr.serialize(ref inputs);
 
-    handle_cheatcode(cheatcode::<'mock_call'>(inputs.span()));
+    execute_cheatcode_and_deserialize::<'mock_call', ()>(inputs.span());
 }
 
 /// Cancels the `mock_call` / `start_mock_call` for the function with given name and contract
@@ -91,9 +90,9 @@ pub fn start_mock_call<T, impl TSerde: core::serde::Serde<T>, impl TDestruct: De
 /// macro)
 pub fn stop_mock_call(contract_address: ContractAddress, function_selector: felt252) {
     let contract_address_felt: felt252 = contract_address.into();
-    handle_cheatcode(
-        cheatcode::<'stop_mock_call'>(array![contract_address_felt, function_selector].span())
-    );
+    execute_cheatcode_and_deserialize::<
+        'stop_mock_call', ()
+    >(array![contract_address_felt, function_selector].span());
 }
 
 #[derive(Drop, Serde, PartialEq, Debug)]
@@ -114,9 +113,7 @@ pub enum ReplaceBytecodeError {
 pub fn replace_bytecode(
     contract: ContractAddress, new_class: ClassHash
 ) -> Result<(), ReplaceBytecodeError> {
-    let mut cheat_result = handle_cheatcode(
-        cheatcode::<'replace_bytecode'>(array![contract.into(), new_class.into()].span())
-    );
-
-    Serde::deserialize(ref cheat_result).unwrap()
+    execute_cheatcode_and_deserialize::<
+        'replace_bytecode'
+    >(array![contract.into(), new_class.into()].span())
 }

snforge_std/src/cheatcodes/contract_class.cairo

@@ -1,10 +1,6 @@
-use core::clone::Clone;
-use core::serde::Serde;
-use core::traits::TryInto;
-use starknet::{ContractAddress, ClassHash, testing::cheatcode, SyscallResult};
+use starknet::{ContractAddress, ClassHash, SyscallResult};
 use super::super::byte_array::byte_array_as_felt_array;
-use super::super::_cheatcode::handle_cheatcode;
-use core::traits::Into;
+use super::super::_cheatcode::execute_cheatcode_and_deserialize;
 
 #[derive(Drop, Serde, Copy)]
 pub struct ContractClass {
@@ -64,19 +60,15 @@ impl ContractClassImpl of ContractClassTrait {
     ) -> ContractAddress {
         let mut inputs = _prepare_calldata(self.class_hash, constructor_calldata);
 
-        let mut outputs = handle_cheatcode(cheatcode::<'precalculate_address'>(inputs.span()));
-
-        Serde::deserialize(ref outputs).unwrap()
+        execute_cheatcode_and_deserialize::<'precalculate_address'>(inputs.span())
     }
 
     fn deploy(
         self: @ContractClass, constructor_calldata: @Array::<felt252>
     ) -> SyscallResult<(ContractAddress, Span<felt252>)> {
         let mut inputs = _prepare_calldata(self.class_hash, constructor_calldata);
 
-        let mut outputs = handle_cheatcode(cheatcode::<'deploy'>(inputs.span()));
-
-        Serde::deserialize(ref outputs).unwrap()
+        execute_cheatcode_and_deserialize::<'deploy'>(inputs.span())
     }
 
     fn deploy_at(
@@ -87,9 +79,7 @@ impl ContractClassImpl of ContractClassTrait {
         let mut inputs = _prepare_calldata(self.class_hash, constructor_calldata);
         inputs.append(contract_address.into());
 
-        let mut outputs = handle_cheatcode(cheatcode::<'deploy_at'>(inputs.span()));
-
-        Serde::deserialize(ref outputs).unwrap()
+        execute_cheatcode_and_deserialize::<'deploy_at'>(inputs.span())
     }
 
     fn new<T, +Into<T, ClassHash>>(class_hash: T) -> ContractClass {
@@ -121,22 +111,14 @@ impl DeclareResultImpl of DeclareResultTrait {
 /// - `AlreadyDeclared`: Contains `ContractClass` and signals that the contract has already been
 /// declared.
 pub fn declare(contract: ByteArray) -> Result<DeclareResult, Array<felt252>> {
-    let mut span = handle_cheatcode(
-        cheatcode::<'declare'>(byte_array_as_felt_array(@contract).span())
-    );
-
-    Serde::deserialize(ref span).unwrap()
+    execute_cheatcode_and_deserialize::<'declare'>(byte_array_as_felt_array(@contract).span())
 }
 
 /// Retrieves a class hash of a contract deployed under the given address
 /// `contract_address` - target contract address
 /// Returns the `ClassHash` under given address
 pub fn get_class_hash(contract_address: ContractAddress) -> ClassHash {
-    let mut span = handle_cheatcode(
-        cheatcode::<'get_class_hash'>(array![contract_address.into()].span())
-    );
-
-    Serde::deserialize(ref span).unwrap()
+    execute_cheatcode_and_deserialize::<'get_class_hash'>(array![contract_address.into()].span())
 }
 
 fn _prepare_calldata(

snforge_std/src/cheatcodes/events.cairo

@@ -1,15 +1,10 @@
-use core::array::ArrayTrait;
-use core::option::OptionTrait;
-use starknet::testing::cheatcode;
 use starknet::ContractAddress;
-use super::super::_cheatcode::handle_cheatcode;
+use super::super::_cheatcode::execute_cheatcode_and_deserialize;
+
 
 /// Creates `EventSpy` instance that spies on all events emitted after its creation.
 pub fn spy_events() -> EventSpy {
-    let mut event_offset = handle_cheatcode(cheatcode::<'spy_events'>(array![].span()));
-    let parsed_event_offset: usize = Serde::<usize>::deserialize(ref event_offset).unwrap();
-
-    EventSpy { event_offset: parsed_event_offset }
+    execute_cheatcode_and_deserialize::<'spy_events'>(array![].span())
 }
 
 /// Raw event format (as seen via the RPC-API), can be used for asserting the emitted events.
@@ -38,12 +33,7 @@ pub trait EventSpyTrait {
 
 impl EventSpyTraitImpl of EventSpyTrait {
     fn get_events(ref self: EventSpy) -> Events {
-        let mut output = handle_cheatcode(
-            cheatcode::<'get_events'>(array![self.event_offset.into()].span())
-        );
-        let events = Serde::<Array<(ContractAddress, Event)>>::deserialize(ref output).unwrap();
-
-        Events { events }
+        execute_cheatcode_and_deserialize::<'get_events'>(array![self.event_offset.into()].span())
     }
 }
 

snforge_std/src/cheatcodes/execution_info.cairo

@@ -1,7 +1,7 @@
-use starknet::{ContractAddress, testing::cheatcode, contract_address_const};
+use starknet::ContractAddress;
 use starknet::ResourcesBounds;
 use snforge_std::cheatcodes::CheatSpan;
-use super::super::_cheatcode::handle_cheatcode;
+use super::super::_cheatcode::execute_cheatcode_and_deserialize;
 
 pub mod caller_address;
 pub mod block_number;
@@ -145,5 +145,5 @@ fn cheat_execution_info(execution_info_mock: ExecutionInfoMock) {
 
     execution_info_mock.serialize(ref inputs);
 
-    handle_cheatcode(cheatcode::<'cheat_execution_info'>(inputs.span()));
+    execute_cheatcode_and_deserialize::<'cheat_execution_info', ()>(inputs.span());
 }

snforge_std/src/cheatcodes/generate_random_felt.cairo

@@ -1,13 +1,9 @@
-use starknet::testing::cheatcode;
-use core::serde::Serde;
-use super::super::_cheatcode::handle_cheatcode;
+use super::super::_cheatcode::execute_cheatcode_and_deserialize;
 
 
 /// Generates a random felt value
 ///
 /// Returns a random felt within the range of 0 and 2^252 - 1
 pub fn generate_random_felt() -> felt252 {
-    let mut random_felt = handle_cheatcode(cheatcode::<'generate_random_felt'>(array![].span()));
-
-    Serde::deserialize(ref random_felt).unwrap()
+    execute_cheatcode_and_deserialize::<'generate_random_felt'>(array![].span())
 }

snforge_std/src/cheatcodes/l1_handler.cairo

@@ -1,7 +1,5 @@
-use core::array::SpanTrait;
-use core::serde::Serde;
-use starknet::{ContractAddress, testing::cheatcode, SyscallResult};
-use super::super::_cheatcode::handle_cheatcode;
+use starknet::{ContractAddress, SyscallResult};
+use super::super::_cheatcode::execute_cheatcode_and_deserialize;
 
 #[derive(Drop, Clone)]
 pub struct L1Handler {
@@ -38,14 +36,6 @@ impl L1HandlerImpl of L1HandlerTrait {
         ];
         payload.serialize(ref inputs);
 
-        let mut outputs = handle_cheatcode(cheatcode::<'l1_handler_execute'>(inputs.span()));
-        let exit_code = *outputs.pop_front().unwrap();
-
-        if exit_code == 0 {
-            SyscallResult::Ok(())
-        } else {
-            let panic_data = Serde::<Array<felt252>>::deserialize(ref outputs).unwrap();
-            SyscallResult::Err(panic_data)
-        }
+        execute_cheatcode_and_deserialize::<'l1_handler_execute'>(inputs.span())
     }
 }

snforge_std/src/cheatcodes/message_to_l1.cairo

@@ -1,15 +1,9 @@
-use core::array::ArrayTrait;
-use core::option::OptionTrait;
-use starknet::testing::cheatcode;
 use starknet::{ContractAddress, EthAddress};
-use super::super::_cheatcode::handle_cheatcode;
+use super::super::_cheatcode::execute_cheatcode_and_deserialize;
 
 /// Creates `MessageToL1Spy` instance that spies on all messages sent to L1
 pub fn spy_messages_to_l1() -> MessageToL1Spy {
-    let mut message_offset = handle_cheatcode(cheatcode::<'spy_messages_to_l1'>(array![].span()));
-    let parsed_message_offset: usize = Serde::<usize>::deserialize(ref message_offset).unwrap();
-
-    MessageToL1Spy { message_offset: parsed_message_offset }
+    execute_cheatcode_and_deserialize::<'spy_messages_to_l1'>(array![].span())
 }
 
 /// Raw message to L1 format (as seen via the RPC-API), can be used for asserting the sent messages.
@@ -40,13 +34,9 @@ pub trait MessageToL1SpyTrait {
 
 impl MessageToL1SpyTraitImpl of MessageToL1SpyTrait {
     fn get_messages(ref self: MessageToL1Spy) -> MessagesToL1 {
-        let mut output = handle_cheatcode(
-            cheatcode::<'get_messages_to_l1'>(array![self.message_offset.into()].span())
-        );
-        let messages = Serde::<Array<(ContractAddress, MessageToL1)>>::deserialize(ref output)
-            .unwrap();
-
-        MessagesToL1 { messages }
+        execute_cheatcode_and_deserialize::<
+            'get_messages_to_l1'
+        >(array![self.message_offset.into()].span())
     }
 }
 
@@ -144,4 +134,3 @@ fn is_sent(
     };
     return is_emitted;
 }
-

snforge_std/src/cheatcodes/storage.cairo

@@ -1,10 +1,5 @@
-use core::array::ArrayTrait;
-use core::traits::Into;
-use core::option::OptionTrait;
-use core::traits::TryInto;
-use starknet::{testing::cheatcode, ContractAddress, StorageAddress};
-use core::panic_with_felt252;
-use super::super::_cheatcode::handle_cheatcode;
+use starknet::{ContractAddress, StorageAddress};
+use super::super::_cheatcode::execute_cheatcode_and_deserialize;
 
 fn validate_storage_address_felt(storage_address_felt: felt252) {
     let result: Option<StorageAddress> = storage_address_felt.try_into();
@@ -19,13 +14,13 @@ fn validate_storage_address_felt(storage_address_felt: felt252) {
 fn store_felt252(target: ContractAddress, storage_address: felt252, value: felt252) {
     validate_storage_address_felt(storage_address);
     let inputs = array![target.into(), storage_address.into(), value];
-    handle_cheatcode(cheatcode::<'store'>(inputs.span()));
+    execute_cheatcode_and_deserialize::<'store', ()>(inputs.span());
 }
 
 fn load_felt252(target: ContractAddress, storage_address: felt252) -> felt252 {
     validate_storage_address_felt(storage_address);
     let inputs = array![target.into(), storage_address];
-    *handle_cheatcode(cheatcode::<'load'>(inputs.span())).at(0)
+    execute_cheatcode_and_deserialize::<'load'>(inputs.span())
 }
 
 /// Stores felts from `serialized_value` in `target` contract's storage, starting at
@@ -61,5 +56,5 @@ pub fn load(target: ContractAddress, storage_address: felt252, size: felt252) ->
 pub fn map_entry_address(map_selector: felt252, keys: Span<felt252>) -> felt252 {
     let mut inputs = array![map_selector];
     keys.serialize(ref inputs);
-    *handle_cheatcode(cheatcode::<'map_entry_address'>(inputs.span())).at(0)
+    execute_cheatcode_and_deserialize::<'map_entry_address'>(inputs.span())
 }