Use new runner builder in tests

cairo1-run/src/cairo_run.rs

@@ -44,7 +44,7 @@ use cairo_vm::{
     },
     vm::{
         errors::{runner_errors::RunnerError, vm_errors::VirtualMachineError},
-        runners::cairo_runner::{CairoRunner, RunResources, RunnerMode},
+        runners::cairo_runner::{CairoRunner, CairoRunnerBuilder, RunResources, RunnerMode},
         vm_core::VirtualMachine,
     },
     Felt252,
@@ -250,16 +250,25 @@ pub fn cairo_run_program(
         RunnerMode::ExecutionMode
     };
 
-    let mut runner = CairoRunner::new_v2(
+    let mut runner_builder = CairoRunnerBuilder::new(
         &program,
         cairo_run_config.layout,
         cairo_run_config.dynamic_layout_params.clone(),
         runner_mode,
-        cairo_run_config.trace_enabled,
-        false,
     )?;
-    let end = runner.initialize(cairo_run_config.proof_mode)?;
-    load_arguments(&mut runner, &cairo_run_config, main_func)?;
+    runner_builder.enable_trace(cairo_run_config.trace_enabled);
+    runner_builder.allow_missing_builtins(cairo_run_config.proof_mode);
+    runner_builder.initialize_builtin_runners_for_layout()?;
+    runner_builder.initialize_base_segments();
+    runner_builder.load_program()?;
+    runner_builder.initialize_builtin_segments();
+    runner_builder.initialize_builtin_zero_segments();
+    let end = runner_builder.initialize_main_entrypoint()?;
+    runner_builder.initialize_validation_rules()?;
+
+    load_arguments(&mut runner_builder, &cairo_run_config, main_func)?;
+
+    let mut runner = runner_builder.build()?;
 
     // Run it until the end / infinite loop in proof_mode
     runner.run_until_pc(end, &mut hint_processor)?;
@@ -460,7 +469,7 @@ After the entry_code (up until calling main) has been ran by the VM:
 (*4) if gas builtin is present
 */
 fn load_arguments(
-    runner: &mut CairoRunner,
+    runner: &mut CairoRunnerBuilder,
     cairo_run_config: &Cairo1RunConfig,
     main_func: &Function,
 ) -> Result<(), Error> {
@@ -500,25 +509,28 @@ fn load_arguments(
     for arg in cairo_run_config.args {
         match arg {
             FuncArg::Array(args) => {
-                let array_start = runner.vm.add_memory_segment();
-                let array_end = runner.vm.load_data(
+                let array_start = runner.add_memory_segment();
+                let array_end = runner.load_memory_array(
                     array_start,
                     &args.iter().map(|f| f.into()).collect::<Vec<_>>(),
                 )?;
-                runner.vm.insert_value(
-                    (runner.vm.get_ap() + ap_offset).map_err(VirtualMachineError::Math)?,
+                runner.load_memory_value(
+                    (runner.get_initial_ap().ok_or(RunnerError::NoAP)? + ap_offset)
+                        .map_err(VirtualMachineError::Math)?,
                     array_start,
                 )?;
                 ap_offset += 1;
-                runner.vm.insert_value(
-                    (runner.vm.get_ap() + ap_offset).map_err(VirtualMachineError::Math)?,
+                runner.load_memory_value(
+                    (runner.get_initial_ap().ok_or(RunnerError::NoAP)? + ap_offset)
+                        .map_err(VirtualMachineError::Math)?,
                     array_end,
                 )?;
                 ap_offset += 1;
             }
             FuncArg::Single(arg) => {
-                runner.vm.insert_value(
-                    (runner.vm.get_ap() + ap_offset).map_err(VirtualMachineError::Math)?,
+                runner.load_memory_value(
+                    (runner.get_initial_ap().ok_or(RunnerError::NoAP)? + ap_offset)
+                        .map_err(VirtualMachineError::Math)?,
                     arg,
                 )?;
                 ap_offset += 1;

vm/src/cairo_run.rs

@@ -8,7 +8,10 @@ use crate::{
         errors::{
             cairo_run_errors::CairoRunError, runner_errors::RunnerError, vm_exception::VmException,
         },
-        runners::{cairo_pie::CairoPie, cairo_runner::CairoRunner},
+        runners::{
+            cairo_pie::CairoPie,
+            cairo_runner::{CairoRunner, CairoRunnerBuilder, RunnerMode},
+        },
         security::verify_secure_runner,
     },
 };
@@ -77,18 +80,31 @@ pub fn cairo_run_program_with_initial_scope(
         .allow_missing_builtins
         .unwrap_or(cairo_run_config.proof_mode);
 
-    let mut cairo_runner = CairoRunner::new(
+    let mut runner_builder = CairoRunnerBuilder::new(
         program,
         cairo_run_config.layout,
         cairo_run_config.dynamic_layout_params.clone(),
-        cairo_run_config.proof_mode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
+        if cairo_run_config.proof_mode {
+            RunnerMode::ProofModeCanonical
+        } else {
+            RunnerMode::ExecutionMode
+        },
     )?;
+    runner_builder.enable_trace(cairo_run_config.trace_enabled);
+    runner_builder.disable_trace_padding(cairo_run_config.disable_trace_padding);
+    runner_builder.allow_missing_builtins(allow_missing_builtins);
+    runner_builder.initialize_builtin_runners_for_layout()?;
+    runner_builder.initialize_base_segments();
+    runner_builder.load_program()?;
+    runner_builder.initialize_builtin_segments();
+    runner_builder.initialize_builtin_zero_segments();
+    let end = runner_builder.initialize_main_entrypoint()?;
+    runner_builder.initialize_validation_rules()?;
+
+    let mut cairo_runner = runner_builder.build()?;
 
     cairo_runner.exec_scopes = exec_scopes;
 
-    let end = cairo_runner.initialize(allow_missing_builtins)?;
     // check step calculation
 
     cairo_runner
@@ -171,16 +187,26 @@ pub fn cairo_run_pie(
     let allow_missing_builtins = cairo_run_config.allow_missing_builtins.unwrap_or_default();
 
     let program = Program::from_stripped_program(&pie.metadata.program);
-    let mut cairo_runner = CairoRunner::new(
+
+    let mut runner_builder = CairoRunnerBuilder::new(
         &program,
         cairo_run_config.layout,
         cairo_run_config.dynamic_layout_params.clone(),
-        false,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
+        RunnerMode::ExecutionMode,
     )?;
+    runner_builder.enable_trace(cairo_run_config.trace_enabled);
+    runner_builder.disable_trace_padding(cairo_run_config.disable_trace_padding);
+    runner_builder.allow_missing_builtins(allow_missing_builtins);
+    runner_builder.initialize_builtin_runners_for_layout()?;
+    runner_builder.initialize_base_segments();
+    runner_builder.load_program()?;
+    runner_builder.initialize_builtin_segments();
+    runner_builder.initialize_builtin_zero_segments();
+    let end = runner_builder.initialize_main_entrypoint()?;
+    runner_builder.initialize_validation_rules()?;
+
+    let mut cairo_runner = runner_builder.build()?;
 
-    let end = cairo_runner.initialize(allow_missing_builtins)?;
     cairo_runner.vm.finalize_segments_by_cairo_pie(pie);
     // Load builtin additional data
     for (name, data) in pie.additional_data.0.iter() {
@@ -246,16 +272,27 @@ pub fn cairo_run_fuzzed_program(
         .allow_missing_builtins
         .unwrap_or(cairo_run_config.proof_mode);
 
-    let mut cairo_runner = CairoRunner::new(
+    let mut runner_builder = CairoRunnerBuilder::new(
         &program,
         cairo_run_config.layout,
         cairo_run_config.dynamic_layout_params.clone(),
-        cairo_run_config.proof_mode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
+        if cairo_run_config.proof_mode {
+            RunnerMode::ProofModeCanonical
+        } else {
+            RunnerMode::ExecutionMode
+        },
     )?;
-
-    let _end = cairo_runner.initialize(allow_missing_builtins)?;
+    runner_builder.enable_trace(cairo_run_config.trace_enabled);
+    runner_builder.allow_missing_builtins(allow_missing_builtins);
+    runner_builder.disable_trace_padding(cairo_run_config.disable_trace_padding);
+    runner_builder.initialize_builtin_runners_for_layout()?;
+    runner_builder.initialize_base_segments();
+    runner_builder.load_program()?;
+    runner_builder.initialize_builtin_segments();
+    runner_builder.initialize_builtin_zero_segments();
+    runner_builder.initialize_main_entrypoint()?;
+    runner_builder.initialize_validation_rules()?;
+    let mut cairo_runner = runner_builder.build()?;
 
     let res = match cairo_runner.run_until_steps(steps_limit, hint_processor) {
         Err(VirtualMachineError::EndOfProgram(_remaining)) => Ok(()), // program ran OK but ended before steps limit

vm/src/tests/cairo_run_test.rs

@@ -4,7 +4,10 @@ use crate::{tests::*, types::layout_name::LayoutName};
 use crate::{
     utils::test_utils::Program,
     vm::{
-        runners::{builtin_runner::BuiltinRunner, cairo_runner::CairoRunner},
+        runners::{
+            builtin_runner::BuiltinRunner,
+            cairo_runner::{CairoRunnerBuilder, RunnerMode},
+        },
         security::verify_secure_runner,
     },
 };
@@ -1213,17 +1216,32 @@ fn run_program_with_custom_mod_builtin_params(
     };
     let mut hint_processor = BuiltinHintProcessor::new_empty();
     let program = Program::from_bytes(data, Some(cairo_run_config.entrypoint)).unwrap();
-    let mut cairo_runner = CairoRunner::new(
+    let mut runner_builder = CairoRunnerBuilder::new(
         &program,
         cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params,
-        cairo_run_config.proof_mode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
+        cairo_run_config.dynamic_layout_params.clone(),
+        if cairo_run_config.proof_mode {
+            RunnerMode::ProofModeCanonical
+        } else {
+            RunnerMode::ExecutionMode
+        },
     )
     .unwrap();
+    runner_builder.enable_trace(cairo_run_config.trace_enabled);
+    runner_builder.allow_missing_builtins(false);
+    runner_builder.disable_trace_padding(cairo_run_config.disable_trace_padding);
+    runner_builder
+        .initialize_builtin_runners_for_layout()
+        .unwrap();
+    runner_builder.initialize_base_segments();
+    runner_builder.load_program().unwrap();
+    runner_builder.initialize_builtin_segments();
+    runner_builder.initialize_builtin_zero_segments();
+    let end = runner_builder.initialize_main_entrypoint().unwrap();
+    runner_builder.initialize_validation_rules().unwrap();
+
+    let mut cairo_runner = runner_builder.build().unwrap();
 
-    let end = cairo_runner.initialize(false).unwrap();
     // Modify add_mod & mul_mod params
     for runner in cairo_runner.vm.get_builtin_runners_as_mut() {
         if let BuiltinRunner::Mod(runner) = runner {