Remove copied code from cairo1_execution.rs

commit-id:b10cef50

Author: ddoktorski

Cargo.toml

@@ -27,7 +27,7 @@ license = "MIT"
 license-file = "LICENSE"
 
 [workspace.dependencies]
-blockifier = { git = "https://github.com/ddoktorski/sequencer.git", branch = "main-v0.13.5-modified-sierra-dep", default-features = false, features = ["testing"] }
+blockifier = { git = "https://github.com/ddoktorski/sequencer.git", branch = "main-v0.13.5-modified-sierra-dep", default-features = false, features = ["testing", "tracing"] }
 starknet_api = { git = "https://github.com/ddoktorski/sequencer.git", branch = "main-v0.13.5-modified-sierra-dep" }
 cairo-lang-casm = { version = "2.11.2", features = ["serde"] }
 cairo-lang-runner = "2.11.2"

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

@@ -7,125 +7,25 @@ use crate::runtime_extensions::common::get_relocated_vm_trace;
 use blockifier::execution::contract_class::CompiledClassV1;
 use blockifier::execution::entry_point::ExecutableCallEntryPoint;
 use blockifier::execution::entry_point_execution::{
-    VmExecutionContext, finalize_execution, prepare_call_arguments,
-};
-use blockifier::execution::errors::PreExecutionError;
-use blockifier::execution::execution_utils::{
-    ReadOnlySegments, write_felt, write_maybe_relocatable,
+    ExecutionRunnerMode, VmExecutionContext, finalize_execution,
+    initialize_execution_context_with_runner_mode, prepare_call_arguments,
 };
 use blockifier::execution::stack_trace::{
     Cairo1RevertHeader, extract_trailing_cairo1_revert_trace,
 };
-use blockifier::execution::syscalls::hint_processor::SyscallHintProcessor;
-use blockifier::versioned_constants::GasCosts;
 use blockifier::{
     execution::{
         contract_class::EntryPointV1, entry_point::EntryPointExecutionContext,
         errors::EntryPointExecutionError, execution_utils::Args,
     },
     state::state_api::State,
 };
-use cairo_vm::types::layout_name::LayoutName;
-use cairo_vm::types::relocatable::MaybeRelocatable;
 use cairo_vm::vm::errors::cairo_run_errors::CairoRunError;
 use cairo_vm::{
     hint_processor::hint_processor_definition::HintProcessor,
     vm::runners::cairo_runner::{CairoArg, CairoRunner},
 };
 use runtime::{ExtendedRuntime, StarknetRuntime};
-use starknet_types_core::felt::Felt;
-
-// TODO(#2957) remove copied code
-// Copied from https://github.com/starkware-libs/sequencer/blob/545761f29b859d06f125bd6c332b6182845734f0/crates/blockifier/src/execution/entry_point_execution.rs#L145
-fn prepare_program_extra_data(
-    runner: &mut CairoRunner,
-    contract_class: &CompiledClassV1,
-    read_only_segments: &mut ReadOnlySegments,
-    gas_costs: &GasCosts,
-) -> Result<usize, PreExecutionError> {
-    // Create the builtin cost segment, the builtin order should be the same as the price builtin
-    // array in the os in compiled_class.cairo in load_compiled_class_facts.
-    let builtin_price_array = [
-        gas_costs.builtins.pedersen,
-        gas_costs.builtins.bitwise,
-        gas_costs.builtins.ecop,
-        gas_costs.builtins.poseidon,
-        gas_costs.builtins.add_mod,
-        gas_costs.builtins.mul_mod,
-    ];
-
-    let data = builtin_price_array
-        .iter()
-        .map(|&x| MaybeRelocatable::from(Felt::from(x)))
-        .collect::<Vec<_>>();
-    let builtin_cost_segment_start = read_only_segments.allocate(&mut runner.vm, &data)?;
-
-    // Put a pointer to the builtin cost segment at the end of the program (after the
-    // additional `ret` statement).
-    let mut ptr = (runner.vm.get_pc() + contract_class.bytecode_length())?;
-    // Push a `ret` opcode.
-    write_felt(
-        &mut runner.vm,
-        &mut ptr,
-        Felt::from(0x208b_7fff_7fff_7ffe_u128),
-    )?;
-    // Push a pointer to the builtin cost segment.
-    write_maybe_relocatable(&mut runner.vm, &mut ptr, builtin_cost_segment_start)?;
-
-    let program_extra_data_length = 2;
-    Ok(program_extra_data_length)
-}
-
-// TODO(#2957) remove copied code
-// Copied from https://github.com/starkware-libs/sequencer/blob/0e1e92e0b90790e4bec20721c069c312d6a60a13/crates/blockifier/src/execution/entry_point_execution.rs#L98
-fn initialize_execution_context<'a>(
-    call: ExecutableCallEntryPoint,
-    compiled_class: &'a CompiledClassV1,
-    state: &'a mut dyn State,
-    context: &'a mut EntryPointExecutionContext,
-) -> Result<VmExecutionContext<'a>, PreExecutionError> {
-    let entry_point = compiled_class.get_entry_point(&call.type_and_selector())?;
-
-    // Instantiate Cairo runner.
-    let proof_mode = false;
-    // region: Modified blockifier code
-    let trace_enabled = true;
-    let mut runner = CairoRunner::new(
-        &compiled_class.0.program,
-        LayoutName::starknet,
-        proof_mode,
-        trace_enabled,
-    )?;
-    // endregion
-
-    runner.initialize_function_runner_cairo_1(&entry_point.builtins)?;
-    let mut read_only_segments = ReadOnlySegments::default();
-    let program_extra_data_length = prepare_program_extra_data(
-        &mut runner,
-        compiled_class,
-        &mut read_only_segments,
-        &context.versioned_constants().os_constants.gas_costs,
-    )?;
-
-    // Instantiate syscall handler.
-    let initial_syscall_ptr = runner.vm.add_memory_segment();
-    let syscall_handler = SyscallHintProcessor::new(
-        state,
-        context,
-        initial_syscall_ptr,
-        call,
-        &compiled_class.hints,
-        read_only_segments,
-    );
-
-    Ok(VmExecutionContext {
-        runner,
-        syscall_handler,
-        initial_syscall_ptr,
-        entry_point,
-        program_extra_data_length,
-    })
-}
 
 // blockifier/src/execution/cairo1_execution.rs:48 (execute_entry_point_call)
 pub fn execute_entry_point_call_cairo1(
@@ -147,7 +47,13 @@ pub fn execute_entry_point_call_cairo1(
         initial_syscall_ptr,
         entry_point,
         program_extra_data_length,
-    } = initialize_execution_context(call, compiled_class_v1, state, context)?;
+    } = initialize_execution_context_with_runner_mode(
+        call,
+        compiled_class_v1,
+        state,
+        context,
+        ExecutionRunnerMode::Tracing,
+    )?;
 
     let args = prepare_call_arguments(
         &syscall_handler.base.call,