Cheat cairo0 contracts (#835)

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

Closes #797 

## Introduced changes

## Breaking changes

<!-- List of all breaking changes, if applicable -->

## 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`

Author: war-in

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `--clean-cache` flag
 - Changed interface of `L1Handler.execute` and `L1Handler` (dropped `fee` parameter, added result handling with `RevertedTransaction`)
 - cheatcodes (`prank`, `roll`, `warp`, `spoof`, `spy_events`) now work in a test state
+- cheatcodes (`prank`, `roll`, `warp`) now work on forked Cairo 0 contracts
 
 #### Changed
 

Cargo.lock

@@ -67,3 +67,4 @@ rand = "0.8.5"
 project-root = "0.2.2"
 which = "4.4.0"
 conversions = { path = "./crates/conversions" }
+test-case = "3.1.0"

Cargo.toml

@@ -29,7 +29,7 @@ snapbox = "0.4.13"
 indoc.workspace = true
 reqwest = "0.11.18"
 tempfile = "3.8.0"
-test-case = "3.1.0"
+test-case.workspace = true
 fs_extra = "1.3.0"
 sealed_test = "1.0.0"
 dotenv = "0.15.0"

crates/cast/Cargo.toml

@@ -39,6 +39,7 @@ indoc.workspace = true
 dotenv.workspace = true
 rayon.workspace = true
 glob = "0.3.1"
+test-case.workspace = true
 
 
 [lib]

crates/cheatnet/Cargo.toml

@@ -0,0 +1,98 @@
+use crate::execution::deprecated::syscalls::CheatableSyscallHandler;
+use crate::state::CheatnetState;
+use blockifier::execution::call_info::CallInfo;
+use blockifier::execution::contract_class::ContractClassV0;
+use blockifier::execution::deprecated_execution::{
+    finalize_execution, initialize_execution_context, prepare_call_arguments, VmExecutionContext,
+};
+use blockifier::execution::entry_point::{
+    CallEntryPoint, EntryPointExecutionContext, EntryPointExecutionResult, ExecutionResources,
+};
+use blockifier::execution::errors::VirtualMachineExecutionError;
+use blockifier::execution::execution_utils::Args;
+use blockifier::state::state_api::State;
+use cairo_vm::hint_processor::hint_processor_definition::HintProcessor;
+use cairo_vm::vm::runners::cairo_runner::{CairoArg, CairoRunner};
+use cairo_vm::vm::vm_core::VirtualMachine;
+
+// blockifier/src/execution/deprecated_execution.rs:36 (execute_entry_point_call)
+pub fn execute_entry_point_call_cairo0(
+    call: CallEntryPoint,
+    contract_class: ContractClassV0,
+    state: &mut dyn State,
+    cheatnet_state: &mut CheatnetState, // Added parameter
+    resources: &mut ExecutionResources,
+    context: &mut EntryPointExecutionContext,
+) -> EntryPointExecutionResult<CallInfo> {
+    let VmExecutionContext {
+        mut runner,
+        mut vm,
+        mut syscall_handler,
+        initial_syscall_ptr,
+        entry_point_pc,
+    } = initialize_execution_context(&call, contract_class, state, resources, context)?;
+
+    let (implicit_args, args) = prepare_call_arguments(
+        &call,
+        &mut vm,
+        initial_syscall_ptr,
+        &mut syscall_handler.read_only_segments,
+    )?;
+    let n_total_args = args.len();
+
+    // Fix the VM resources, in order to calculate the usage of this run at the end.
+    let previous_vm_resources = syscall_handler.resources.vm_resources.clone();
+
+    // region: Modified blockifier code
+    let mut cheatable_syscall_handler = CheatableSyscallHandler {
+        syscall_handler,
+        cheatnet_state,
+    };
+
+    // Execute.
+    cheatable_run_entry_point(
+        &mut vm,
+        &mut runner,
+        &mut cheatable_syscall_handler,
+        entry_point_pc,
+        &args,
+    )?;
+    // endregion
+
+    Ok(finalize_execution(
+        vm,
+        runner,
+        cheatable_syscall_handler.syscall_handler,
+        call,
+        previous_vm_resources,
+        implicit_args,
+        n_total_args,
+    )?)
+}
+
+// blockifier/src/execution/deprecated_execution.rs:192 (run_entry_point)
+pub fn cheatable_run_entry_point(
+    vm: &mut VirtualMachine,
+    runner: &mut CairoRunner,
+    hint_processor: &mut dyn HintProcessor,
+    entry_point_pc: usize,
+    args: &Args,
+) -> Result<(), VirtualMachineExecutionError> {
+    // region: Modified blockifier code
+    // Opposite to blockifier
+    let verify_secure = false;
+    // endregion
+    let program_segment_size = None; // Infer size from program.
+    let args: Vec<&CairoArg> = args.iter().collect();
+
+    runner.run_from_entrypoint(
+        entry_point_pc,
+        &args,
+        verify_secure,
+        program_segment_size,
+        vm,
+        hint_processor,
+    )?;
+
+    Ok(())
+}

crates/cheatnet/src/execution/deprecated/cairo0_execution.rs

@@ -0,0 +1,76 @@
+use crate::execution::deprecated::syscalls::CheatableSyscallHandler;
+use crate::execution::entry_point::execute_call_entry_point;
+use blockifier::abi::constants;
+use blockifier::execution::deprecated_syscalls::DeprecatedSyscallResult;
+use blockifier::execution::entry_point::{CallEntryPoint, CallType};
+use blockifier::execution::execution_utils::ReadOnlySegment;
+use cairo_vm::types::relocatable::MaybeRelocatable;
+use cairo_vm::vm::vm_core::VirtualMachine;
+use conversions::StarknetConversions;
+use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector};
+use starknet_api::deprecated_contract_class::EntryPointType;
+use starknet_api::transaction::Calldata;
+
+// blockifier/src/execution/deprecated_syscalls/hint_processor.rs:393 (execute_inner_call)
+pub fn execute_inner_call(
+    call: &mut CallEntryPoint,
+    vm: &mut VirtualMachine,
+    syscall_handler: &mut CheatableSyscallHandler<'_>,
+) -> DeprecatedSyscallResult<ReadOnlySegment> {
+    // region: Modified blockifier code
+    let call_info = execute_call_entry_point(
+        call,
+        syscall_handler.syscall_handler.state,
+        syscall_handler.cheatnet_state,
+        syscall_handler.syscall_handler.resources,
+        syscall_handler.syscall_handler.context,
+    )?;
+    // endregion
+
+    let retdata = &call_info.execution.retdata.0;
+    let retdata: Vec<MaybeRelocatable> = retdata
+        .iter()
+        .map(|&x| MaybeRelocatable::from(x.to_felt252()))
+        .collect();
+    let retdata_segment_start_ptr = syscall_handler
+        .syscall_handler
+        .read_only_segments
+        .allocate(vm, &retdata)?;
+
+    syscall_handler.syscall_handler.inner_calls.push(call_info);
+    Ok(ReadOnlySegment {
+        start_ptr: retdata_segment_start_ptr,
+        length: retdata.len(),
+    })
+}
+
+// blockifier/src/execution/deprecated_syscalls/hint_processor.rs:409 (execute_library_call)
+pub fn execute_library_call(
+    syscall_handler: &mut CheatableSyscallHandler<'_>,
+    vm: &mut VirtualMachine,
+    class_hash: ClassHash,
+    code_address: Option<ContractAddress>,
+    call_to_external: bool,
+    entry_point_selector: EntryPointSelector,
+    calldata: Calldata,
+) -> DeprecatedSyscallResult<ReadOnlySegment> {
+    let entry_point_type = if call_to_external {
+        EntryPointType::External
+    } else {
+        EntryPointType::L1Handler
+    };
+    let mut entry_point = CallEntryPoint {
+        class_hash: Some(class_hash),
+        code_address,
+        entry_point_type,
+        entry_point_selector,
+        calldata,
+        // The call context remains the same in a library call.
+        storage_address: syscall_handler.syscall_handler.storage_address,
+        caller_address: syscall_handler.syscall_handler.caller_address,
+        call_type: CallType::Delegate,
+        initial_gas: constants::INITIAL_GAS_COST,
+    };
+
+    execute_inner_call(&mut entry_point, vm, syscall_handler)
+}

crates/cheatnet/src/execution/deprecated/calls.rs

@@ -0,0 +1,3 @@
+pub mod cairo0_execution;
+pub mod calls;
+pub mod syscalls;