feat: refactor CairoRunner ctors to accept CairoLayout directly

Author: dorimedini-starkware

CHANGELOG.md

@@ -12,6 +12,8 @@ Both branches support Stwo prover opcodes (Blake2s, QM31) since v2.0.0.
 
 #### Upcoming Changes
 
+* feat: refactor CairoRunner ctors to accept CairoLayout directly [#2363](https://github.com/starkware-libs/cairo-vm/pull/2363)
+
 * feat: implement CairoLayout::new from layout name and dynamic params [#2362](https://github.com/starkware-libs/cairo-vm/pull/2362)
 
 * Add Stwo cairo runner API [#2351](https://github.com/lambdaclass/cairo-vm/pull/2351)

README.md

@@ -229,7 +229,8 @@ When running a Cairo program directly using the Cairo-vm repository you would fi
 2. Instantiate the VM, the cairo_runner, the hint processor, and the entrypoint
 
   ```rust
-  let mut cairo_runner = CairoRunner::new(&program, LayoutName::all_cairo, false, false);
+  let mut cairo_runner =
+      CairoRunner::new(&program, CairoLayout::new(LayoutName::all_cairo, None)?, false, false);
 
   let mut hint_processor = BuiltinHintProcessor::new_empty();
 

bench/criterion_benchmark.rs

@@ -1,5 +1,5 @@
 use cairo_vm::{
-    types::{layout_name::LayoutName, program::Program},
+    types::{layout::CairoLayout, layout_name::LayoutName, program::Program},
     vm::runners::cairo_runner::CairoRunner,
 };
 use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
@@ -29,8 +29,7 @@ fn build_many_runners(c: &mut Criterion) {
             _ = black_box(
                 CairoRunner::new(
                     black_box(&program),
-                    black_box(LayoutName::starknet_with_keccak),
-                    black_box(None),
+                    black_box(CairoLayout::new(LayoutName::starknet_with_keccak, None).unwrap()),
                     black_box(false),
                     black_box(false),
                     black_box(false),
@@ -50,8 +49,7 @@ fn load_program_data(c: &mut Criterion) {
             || {
                 CairoRunner::new(
                     &program,
-                    LayoutName::starknet_with_keccak,
-                    None,
+                    CairoLayout::new(LayoutName::starknet_with_keccak, None).unwrap(),
                     false,
                     false,
                     false,

bench/iai_benchmark.rs

@@ -1,3 +1,4 @@
+use cairo_vm::types::layout::CairoLayout;
 use core::hint::black_box;
 use iai_callgrind::library_benchmark;
 use iai_callgrind::library_benchmark_group;
@@ -36,8 +37,7 @@ fn build_runner() {
     let program = parse_program_helper();
     let runner = CairoRunner::new(
         black_box(&program),
-        LayoutName::starknet_with_keccak,
-        None,
+        CairoLayout::new(LayoutName::starknet_with_keccak, None).unwrap(),
         false,
         false,
         false,
@@ -54,8 +54,7 @@ fn build_runner_helper() -> CairoRunner {
     let program = Program::from_bytes(program.as_slice(), Some("main")).unwrap();
     CairoRunner::new(
         &program,
-        LayoutName::starknet_with_keccak,
-        None,
+        CairoLayout::new(LayoutName::starknet_with_keccak, None).unwrap(),
         false,
         false,
         false,

cairo-vm-cli/src/main.rs

@@ -269,7 +269,8 @@ mod tests {
     use super::*;
     use assert_matches::assert_matches;
     use cairo_vm::{
-        hint_processor::hint_processor_definition::HintProcessor, types::program::Program,
+        hint_processor::hint_processor_definition::HintProcessor,
+        types::{layout::CairoLayout, program::Program},
         vm::runners::cairo_runner::CairoRunner,
     };
     use rstest::rstest;
@@ -280,8 +281,14 @@ mod tests {
         hint_processor: &mut dyn HintProcessor,
     ) -> Result<CairoRunner, CairoRunError> {
         let program = Program::from_bytes(program_content, Some("main")).unwrap();
-        let mut cairo_runner =
-            CairoRunner::new(&program, LayoutName::all_cairo, None, false, true, false).unwrap();
+        let mut cairo_runner = CairoRunner::new(
+            &program,
+            CairoLayout::new(LayoutName::all_cairo, None).unwrap(),
+            false,
+            true,
+            false,
+        )
+        .unwrap();
         let end = cairo_runner
             .initialize(false)
             .map_err(CairoRunError::Runner)?;

cairo1-run/src/cairo_run.rs

@@ -41,8 +41,11 @@ use cairo_vm::{
     math_utils::signed_felt,
     serde::deserialize_program::{ApTracking, FlowTrackingData, HintParams, ReferenceManager},
     types::{
-        builtin_name::BuiltinName, layout::CairoLayoutParams, layout_name::LayoutName,
-        program::Program, relocatable::MaybeRelocatable,
+        builtin_name::BuiltinName,
+        layout::{CairoLayout, CairoLayoutParams},
+        layout_name::LayoutName,
+        program::Program,
+        relocatable::MaybeRelocatable,
     },
     vm::{
         errors::{runner_errors::RunnerError, vm_errors::VirtualMachineError},
@@ -258,12 +261,15 @@ pub fn cairo_run_program(
 
     let mut runner = CairoRunner::new_v2(
         &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
+        CairoLayout::new(
+            cairo_run_config.layout,
+            cairo_run_config.dynamic_layout_params.clone(),
+        )
+        .map_err(RunnerError::from)?,
         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)?;
 

vm/src/cairo_run.rs

@@ -1,7 +1,9 @@
 use crate::{
     hint_processor::hint_processor_definition::HintProcessor,
     types::{
-        builtin_name::BuiltinName, layout::CairoLayoutParams, layout_name::LayoutName,
+        builtin_name::BuiltinName,
+        layout::{CairoLayout, CairoLayoutParams},
+        layout_name::LayoutName,
         program::Program,
     },
     vm::{
@@ -165,8 +167,11 @@ pub fn cairo_run_program_with_initial_scope(
 
     let mut cairo_runner = CairoRunner::new(
         program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
+        CairoLayout::new(
+            cairo_run_config.layout,
+            cairo_run_config.dynamic_layout_params.clone(),
+        )
+        .map_err(RunnerError::from)?,
         cairo_run_config.proof_mode,
         cairo_run_config.trace_enabled,
         cairo_run_config.disable_trace_padding,
@@ -272,8 +277,11 @@ pub fn cairo_run_pie(
     let program = Program::from_stripped_program(&pie.metadata.program);
     let mut cairo_runner = CairoRunner::new(
         &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
+        CairoLayout::new(
+            cairo_run_config.layout,
+            cairo_run_config.dynamic_layout_params.clone(),
+        )
+        .map_err(RunnerError::from)?,
         false,
         cairo_run_config.trace_enabled,
         cairo_run_config.disable_trace_padding,
@@ -430,8 +438,11 @@ pub fn cairo_run_fuzzed_program(
 
     let mut cairo_runner = CairoRunner::new(
         &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
+        CairoLayout::new(
+            cairo_run_config.layout,
+            cairo_run_config.dynamic_layout_params.clone(),
+        )
+        .map_err(RunnerError::from)?,
         cairo_run_config.proof_mode,
         cairo_run_config.trace_enabled,
         cairo_run_config.disable_trace_padding,
@@ -641,6 +652,24 @@ mod tests {
         assert_eq!(&output_buffer, "0\n");
     }
 
+    #[cfg(feature = "test_utils")]
+    #[test]
+    fn test_cairo_run_fuzzed_program() {
+        let program = Program::from_bytes(
+            include_bytes!("../../cairo_programs/struct.json"),
+            Some("main"),
+        )
+        .unwrap();
+        let mut hint_processor = BuiltinHintProcessor::new_empty();
+        cairo_run_fuzzed_program(
+            program,
+            &CairoRunConfig::default(),
+            &mut hint_processor,
+            1000,
+        )
+        .unwrap();
+    }
+
     #[test]
     fn run_with_no_trace() {
         let program = Program::from_bytes(

vm/src/tests/cairo_run_test.rs

@@ -2,6 +2,7 @@ use crate::{tests::*, types::layout_name::LayoutName};
 
 #[cfg(feature = "mod_builtin")]
 use crate::{
+    types::layout::CairoLayout,
     utils::test_utils::Program,
     vm::{
         runners::{builtin_runner::BuiltinRunner, cairo_runner::CairoRunner},
@@ -1071,8 +1072,11 @@ fn run_program_with_custom_mod_builtin_params(
     let program = Program::from_bytes(data, Some(cairo_run_config.entrypoint)).unwrap();
     let mut cairo_runner = CairoRunner::new(
         &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params,
+        CairoLayout::new(
+            cairo_run_config.layout,
+            cairo_run_config.dynamic_layout_params,
+        )
+        .unwrap(),
         cairo_run_config.proof_mode,
         cairo_run_config.trace_enabled,
         cairo_run_config.disable_trace_padding,

vm/src/tests/mod.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "cairo-1-hints")]
+use crate::types::layout::CairoLayout;
 use crate::types::layout_name::LayoutName;
 #[cfg(all(feature = "cairo-1-hints", feature = "test_utils"))]
 use crate::vm::errors::cairo_run_errors::CairoRunError;
@@ -107,8 +109,7 @@ fn run_cairo_1_entrypoint(
 
     let mut runner = CairoRunner::new(
         &(contract_class.clone().try_into().unwrap()),
-        LayoutName::all_cairo,
-        None,
+        CairoLayout::new(LayoutName::all_cairo, None).unwrap(),
         false,
         false,
         false,
@@ -215,8 +216,7 @@ fn run_cairo_1_entrypoint_with_run_resources(
 ) -> Result<Vec<Felt252>, CairoRunError> {
     let mut runner = CairoRunner::new(
         &(contract_class.clone().try_into().unwrap()),
-        LayoutName::all_cairo,
-        None,
+        CairoLayout::new(LayoutName::all_cairo, None).unwrap(),
         false,
         false,
         false,

vm/src/types/layout.rs

@@ -41,7 +41,7 @@ pub struct CairoLayout {
 }
 
 impl CairoLayout {
-    pub(crate) fn new(
+    pub fn new(
         layout: LayoutName,
         dynamic_layout_params: Option<CairoLayoutParams>,
     ) -> Result<CairoLayout, CairoLayoutError> {