diff --git a/CHANGELOG.md b/CHANGELOG.md index ba5904a56f..2b21dccba8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,8 @@ Both branches support Stwo prover opcodes (Blake2s, QM31) since v2.0.0. #### Upcoming Changes +* feat: generic cairo run config for runner ctors [#2360](https://github.com/phil-starkware/cairo-vm/pull/2360) + * Add Stwo cairo runner API [#2351](https://github.com/lambdaclass/cairo-vm/pull/2351) * Add union merge strategy for CHANGELOG.md [#2345](https://github.com/lambdaclass/cairo-vm/pull/2345) diff --git a/bench/criterion_benchmark.rs b/bench/criterion_benchmark.rs index 86a032df56..5638167f2b 100644 --- a/bench/criterion_benchmark.rs +++ b/bench/criterion_benchmark.rs @@ -1,4 +1,5 @@ use cairo_vm::{ + cairo_run::CairoRunConfig, types::{layout_name::LayoutName, program::Program}, vm::runners::cairo_runner::CairoRunner, }; @@ -29,11 +30,10 @@ 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(false), - black_box(false), - black_box(false), + black_box(&CairoRunConfig { + layout: LayoutName::starknet_with_keccak, + ..Default::default() + }), ) .unwrap(), ); @@ -50,11 +50,10 @@ fn load_program_data(c: &mut Criterion) { || { CairoRunner::new( &program, - LayoutName::starknet_with_keccak, - None, - false, - false, - false, + &CairoRunConfig { + layout: LayoutName::starknet_with_keccak, + ..Default::default() + }, ) .unwrap() }, diff --git a/bench/iai_benchmark.rs b/bench/iai_benchmark.rs index 4d0922a789..3baa424945 100644 --- a/bench/iai_benchmark.rs +++ b/bench/iai_benchmark.rs @@ -36,11 +36,10 @@ fn build_runner() { let program = parse_program_helper(); let runner = CairoRunner::new( black_box(&program), - LayoutName::starknet_with_keccak, - None, - false, - false, - false, + &CairoRunConfig { + layout: LayoutName::starknet_with_keccak, + ..Default::default() + }, ) .unwrap(); core::mem::drop(black_box(runner)); @@ -54,11 +53,10 @@ fn build_runner_helper() -> CairoRunner { let program = Program::from_bytes(program.as_slice(), Some("main")).unwrap(); CairoRunner::new( &program, - LayoutName::starknet_with_keccak, - None, - false, - false, - false, + &CairoRunConfig { + layout: LayoutName::starknet_with_keccak, + ..Default::default() + }, ) .unwrap() } diff --git a/cairo-vm-cli/src/main.rs b/cairo-vm-cli/src/main.rs index bbc0eee9f3..aff559529e 100644 --- a/cairo-vm-cli/src/main.rs +++ b/cairo-vm-cli/src/main.rs @@ -280,8 +280,15 @@ mod tests { hint_processor: &mut dyn HintProcessor, ) -> Result { 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, + &CairoRunConfig { + layout: LayoutName::all_cairo, + trace_enabled: true, + ..Default::default() + }, + ) + .unwrap(); let end = cairo_runner .initialize(false) .map_err(CairoRunError::Runner)?; diff --git a/cairo1-run/src/cairo_run.rs b/cairo1-run/src/cairo_run.rs index ae01d735a7..9b218ef7fd 100644 --- a/cairo1-run/src/cairo_run.rs +++ b/cairo1-run/src/cairo_run.rs @@ -37,6 +37,7 @@ use cairo_lang_utils::{ use std::{collections::HashMap, iter::Peekable}; use cairo_vm::{ + cairo_run::CommonCairoRunConfig, hint_processor::cairo_1_hint_processor::hint_processor::Cairo1HintProcessor, math_utils::signed_felt, serde::deserialize_program::{ApTracking, FlowTrackingData, HintParams, ReferenceManager}, @@ -119,6 +120,33 @@ impl Default for Cairo1RunConfig<'_> { } } +impl CommonCairoRunConfig for Cairo1RunConfig<'_> { + fn trace_enabled(&self) -> bool { + self.trace_enabled + } + + fn relocate_mem(&self) -> bool { + self.relocate_mem + } + + fn layout(&self) -> LayoutName { + self.layout + } + + fn dynamic_layout_params(&self) -> Option { + self.dynamic_layout_params.clone() + } + + fn proof_mode(&self) -> bool { + self.proof_mode + } + + fn disable_trace_padding(&self) -> bool { + // Always false in Cairo1. + false + } +} + impl Cairo1RunConfig<'_> { // Returns true if the flags in the config enable adding the output builtin and // copying input and output values into it's segment @@ -256,14 +284,7 @@ pub fn cairo_run_program( RunnerMode::ExecutionMode }; - let mut runner = CairoRunner::new_v2( - &program, - cairo_run_config.layout, - cairo_run_config.dynamic_layout_params.clone(), - runner_mode, - cairo_run_config.trace_enabled, - false, - )?; + let mut runner = CairoRunner::new_v2(&program, &cairo_run_config, runner_mode)?; let end = runner.initialize(cairo_run_config.proof_mode)?; load_arguments(&mut runner, &cairo_run_config, main_func)?; diff --git a/vm/src/cairo_run.rs b/vm/src/cairo_run.rs index 3f206d5d2c..831d567bff 100644 --- a/vm/src/cairo_run.rs +++ b/vm/src/cairo_run.rs @@ -24,7 +24,17 @@ use arbitrary::{self, Arbitrary}; use core::fmt; use tracing::{info, span, Level}; +pub trait CommonCairoRunConfig { + fn trace_enabled(&self) -> bool; + fn relocate_mem(&self) -> bool; + fn layout(&self) -> LayoutName; + fn dynamic_layout_params(&self) -> Option; + fn proof_mode(&self) -> bool; + fn disable_trace_padding(&self) -> bool; +} + #[cfg_attr(feature = "test_utils", derive(Arbitrary))] +#[derive(Clone)] pub struct CairoRunConfig<'a> { #[cfg_attr(feature = "test_utils", arbitrary(value = "main"))] pub entrypoint: &'a str, @@ -70,6 +80,32 @@ impl Default for CairoRunConfig<'_> { } } +impl CommonCairoRunConfig for CairoRunConfig<'_> { + fn trace_enabled(&self) -> bool { + self.trace_enabled + } + + fn relocate_mem(&self) -> bool { + self.relocate_mem + } + + fn layout(&self) -> LayoutName { + self.layout + } + + fn dynamic_layout_params(&self) -> Option { + self.dynamic_layout_params.clone() + } + + fn proof_mode(&self) -> bool { + self.proof_mode + } + + fn disable_trace_padding(&self) -> bool { + self.disable_trace_padding + } +} + pub struct StwoCairoRunConfig { pub trace_enabled: bool, pub relocate_mem: bool, @@ -92,6 +128,33 @@ impl Default for StwoCairoRunConfig { } } +impl CommonCairoRunConfig for StwoCairoRunConfig { + fn trace_enabled(&self) -> bool { + self.trace_enabled + } + + fn relocate_mem(&self) -> bool { + self.relocate_mem + } + + fn layout(&self) -> LayoutName { + LayoutName::all_cairo_stwo + } + + fn dynamic_layout_params(&self) -> Option { + None + } + + fn proof_mode(&self) -> bool { + // Unused. + true + } + + fn disable_trace_padding(&self) -> bool { + self.disable_trace_padding + } +} + #[allow(clippy::result_large_err)] pub fn cairo_run_stwo( program: &Program, @@ -104,12 +167,7 @@ pub fn cairo_run_stwo( let _span = span!(Level::INFO, "cairo run stwo").entered(); let proof_mode = runner_mode != RunnerMode::ExecutionMode; - let mut cairo_runner = CairoRunner::new_stwo( - program, - runner_mode, - cairo_run_config.trace_enabled, - cairo_run_config.disable_trace_padding, - )?; + let mut cairo_runner = CairoRunner::new_stwo(program, cairo_run_config, runner_mode)?; cairo_runner.exec_scopes = exec_scopes; let end = cairo_runner.initialize_stwo(allowed_builtins)?; @@ -163,14 +221,7 @@ pub fn cairo_run_program_with_initial_scope( .allow_missing_builtins .unwrap_or(cairo_run_config.proof_mode); - let mut cairo_runner = CairoRunner::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, - )?; + let mut cairo_runner = CairoRunner::new(program, cairo_run_config)?; cairo_runner.exec_scopes = exec_scopes; @@ -272,11 +323,10 @@ 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(), - false, - cairo_run_config.trace_enabled, - cairo_run_config.disable_trace_padding, + &CairoRunConfig { + proof_mode: false, + ..cairo_run_config.clone() + }, )?; let end = cairo_runner.initialize(allow_missing_builtins)?; @@ -352,12 +402,8 @@ pub fn cairo_run_pie_stwo( pie.run_validity_checks()?; let program = Program::from_stripped_program(&pie.metadata.program); - let mut cairo_runner = CairoRunner::new_stwo( - &program, - RunnerMode::ExecutionMode, - cairo_run_config.trace_enabled, - cairo_run_config.disable_trace_padding, - )?; + let mut cairo_runner = + CairoRunner::new_stwo(&program, cairo_run_config, RunnerMode::ExecutionMode)?; let end = cairo_runner.initialize_stwo(allowed_builtins)?; cairo_runner.vm.finalize_segments_by_cairo_pie(pie); @@ -428,14 +474,7 @@ pub fn cairo_run_fuzzed_program( .allow_missing_builtins .unwrap_or(cairo_run_config.proof_mode); - let mut cairo_runner = CairoRunner::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, - )?; + let mut cairo_runner = CairoRunner::new(&program, &cairo_run_config)?; let _end = cairo_runner.initialize(allow_missing_builtins)?; diff --git a/vm/src/tests/cairo_run_test.rs b/vm/src/tests/cairo_run_test.rs index d1539d8612..095c376c67 100644 --- a/vm/src/tests/cairo_run_test.rs +++ b/vm/src/tests/cairo_run_test.rs @@ -1069,15 +1069,7 @@ 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( - &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, - ) - .unwrap(); + let mut cairo_runner = CairoRunner::new(&program, &cairo_run_config).unwrap(); let end = cairo_runner.initialize(false).unwrap(); // Modify add_mod & mul_mod params diff --git a/vm/src/tests/mod.rs b/vm/src/tests/mod.rs index 2746df2252..ad4df3d5d4 100644 --- a/vm/src/tests/mod.rs +++ b/vm/src/tests/mod.rs @@ -106,11 +106,10 @@ fn run_cairo_1_entrypoint( let mut runner = CairoRunner::new( &(contract_class.clone().try_into().unwrap()), - LayoutName::all_cairo, - None, - false, - false, - false, + &CairoRunConfig { + layout: LayoutName::all_cairo, + ..Default::default() + }, ) .unwrap(); @@ -213,11 +212,10 @@ fn run_cairo_1_entrypoint_with_run_resources( ) -> Result, CairoRunError> { let mut runner = CairoRunner::new( &(contract_class.clone().try_into().unwrap()), - LayoutName::all_cairo, - None, - false, - false, - false, + &CairoRunConfig { + layout: LayoutName::all_cairo, + ..Default::default() + }, ) .unwrap(); diff --git a/vm/src/utils.rs b/vm/src/utils.rs index 247443ac31..45867bd933 100644 --- a/vm/src/utils.rs +++ b/vm/src/utils.rs @@ -250,39 +250,40 @@ pub mod test_utils { ($program:expr) => { crate::vm::runners::cairo_runner::CairoRunner::new( &$program, - crate::types::layout_name::LayoutName::all_cairo, - None, - false, - false, - false, + &crate::cairo_run::CairoRunConfig::default(), ) .unwrap() }; ($program:expr, $layout:expr) => { crate::vm::runners::cairo_runner::CairoRunner::new( - &$program, $layout, None, false, false, false, + &$program, + &crate::cairo_run::CairoRunConfig { + layout: $layout, + ..Default::default() + }, ) .unwrap() }; ($program:expr, $layout:expr, $proof_mode:expr) => { crate::vm::runners::cairo_runner::CairoRunner::new( &$program, - $layout, - None, - $proof_mode, - false, - false, + &crate::cairo_run::CairoRunConfig { + layout: $layout, + proof_mode: $proof_mode, + ..Default::default() + }, ) .unwrap() }; ($program:expr, $layout:expr, $proof_mode:expr, $trace_enabled:expr) => { crate::vm::runners::cairo_runner::CairoRunner::new( &$program, - $layout, - None, - $proof_mode, - $trace_enabled, - false, + &crate::cairo_run::CairoRunConfig { + layout: $layout, + proof_mode: $proof_mode, + trace_enabled: $trace_enabled, + ..Default::default() + }, ) .unwrap() }; diff --git a/vm/src/vm/runners/builtin_runner/modulo.rs b/vm/src/vm/runners/builtin_runner/modulo.rs index 2a0c42726e..607c93893b 100644 --- a/vm/src/vm/runners/builtin_runner/modulo.rs +++ b/vm/src/vm/runners/builtin_runner/modulo.rs @@ -810,6 +810,7 @@ mod tests { fn test_air_private_input_all_cairo() { use crate::{ air_private_input::{ModInput, ModInputInstance, ModInputMemoryVars, PrivateInput}, + cairo_run::CairoRunConfig, hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::layout_name::LayoutName, utils::test_utils::Program, @@ -826,11 +827,11 @@ mod tests { let proof_mode = true; let mut runner = CairoRunner::new( &program, - LayoutName::all_cairo, - None, - proof_mode, - false, - false, + CairoRunConfig { + layout: LayoutName::all_cairo, + proof_mode, + ..Default::default() + }, ) .unwrap(); diff --git a/vm/src/vm/runners/cairo_runner.rs b/vm/src/vm/runners/cairo_runner.rs index 82f620292b..8c1495f637 100644 --- a/vm/src/vm/runners/cairo_runner.rs +++ b/vm/src/vm/runners/cairo_runner.rs @@ -1,4 +1,4 @@ -use crate::vm::trace::trace_entry::TraceEntry; +use crate::{cairo_run::CommonCairoRunConfig, vm::trace::trace_entry::TraceEntry}; use std::{ any::Any, @@ -10,7 +10,7 @@ use crate::{ air_private_input::AirPrivateInput, air_public_input::{PublicInput, PublicInputError}, math_utils::safe_div_usize, - types::{builtin_name::BuiltinName, layout::CairoLayoutParams, layout_name::LayoutName}, + types::{builtin_name::BuiltinName, layout_name::LayoutName}, vm::{ runners::builtin_runner::SegmentArenaBuiltinRunner, trace::trace_entry::{relocate_trace_register, RelocatedTraceEntry}, @@ -188,15 +188,12 @@ pub enum RunnerMode { impl CairoRunner { /// The `dynamic_layout_params` argument should only be used with dynamic layout. /// It is ignored otherwise. - pub fn new_v2( + pub fn new_v2<'a>( program: &Program, - layout: LayoutName, - dynamic_layout_params: Option, + config: &impl CommonCairoRunConfig, mode: RunnerMode, - trace_enabled: bool, - disable_trace_padding: bool, ) -> Result { - let cairo_layout = match layout { + let cairo_layout = match config.layout() { LayoutName::plain => CairoLayout::plain_instance(), LayoutName::small => CairoLayout::small_instance(), LayoutName::dex => CairoLayout::dex_instance(), @@ -212,15 +209,16 @@ impl CairoRunner { LayoutName::perpetual => CairoLayout::perpetual_instance(), LayoutName::dex_with_bitwise => CairoLayout::dex_with_bitwise_instance(), LayoutName::dynamic => { - let params = - dynamic_layout_params.ok_or(RunnerError::MissingDynamicLayoutParams)?; + let params = config + .dynamic_layout_params() + .ok_or(RunnerError::MissingDynamicLayoutParams)?; CairoLayout::dynamic_instance(params)? } }; Ok(CairoRunner { program: program.clone(), - vm: VirtualMachine::new(trace_enabled, disable_trace_padding), + vm: VirtualMachine::new(config.trace_enabled(), config.disable_trace_padding()), layout: cairo_layout, final_pc: None, program_base: None, @@ -249,16 +247,15 @@ impl CairoRunner { /// Must be paired with `initialize_stwo`. Do not use with `initialize`. pub fn new_stwo( program: &Program, + config: &impl CommonCairoRunConfig, mode: RunnerMode, - trace_enabled: bool, - disable_trace_padding: bool, ) -> Result { - if disable_trace_padding && mode == RunnerMode::ExecutionMode { + if config.disable_trace_padding() && mode == RunnerMode::ExecutionMode { return Err(RunnerError::DisableTracePaddingWithoutProofMode); } Ok(CairoRunner { program: program.clone(), - vm: VirtualMachine::new(trace_enabled, disable_trace_padding), + vm: VirtualMachine::new(config.trace_enabled(), config.disable_trace_padding()), layout: CairoLayout::all_cairo_stwo_instance(), final_pc: None, program_base: None, @@ -299,37 +296,19 @@ impl CairoRunner { Ok(end) } - pub fn new( + pub fn new<'a>( program: &Program, - layout: LayoutName, - dynamic_layout_params: Option, - proof_mode: bool, - trace_enabled: bool, - disable_trace_padding: bool, + config: &impl CommonCairoRunConfig, ) -> Result { // `disable_trace_padding` can only be used in `proof_mode`, so we enforce this here to // avoid unintended behavior. - if disable_trace_padding && !proof_mode { + if config.disable_trace_padding() && !config.proof_mode() { return Err(RunnerError::DisableTracePaddingWithoutProofMode); } - if proof_mode { - Self::new_v2( - program, - layout, - dynamic_layout_params, - RunnerMode::ProofModeCanonical, - trace_enabled, - disable_trace_padding, - ) + if config.proof_mode() { + Self::new_v2(program, config, RunnerMode::ProofModeCanonical) } else { - Self::new_v2( - program, - layout, - dynamic_layout_params, - RunnerMode::ExecutionMode, - trace_enabled, - disable_trace_padding, - ) + Self::new_v2(program, config, RunnerMode::ExecutionMode) } } @@ -1794,7 +1773,7 @@ impl MulAssign for ExecutionResources { mod tests { use super::*; use crate::air_private_input::{PrivateInput, PrivateInputSignature, SignatureInput}; - use crate::cairo_run::{cairo_run, CairoRunConfig}; + use crate::cairo_run::{cairo_run, CairoRunConfig, StwoCairoRunConfig}; use crate::types::instance_definitions::bitwise_instance_def::CELLS_PER_BITWISE; use crate::types::instance_definitions::keccak_instance_def::CELLS_PER_KECCAK; use crate::vm::vm_memory::memory::MemoryCell; @@ -5605,7 +5584,12 @@ mod tests { fn test_disable_trace_padding_without_proof_mode() { let program = program!(); // Attempt to create a runner in non-proof mode with trace padding disabled. - let result = CairoRunner::new(&program, LayoutName::plain, None, false, true, true); + let config = CairoRunConfig { + trace_enabled: true, + disable_trace_padding: true, + ..Default::default() + }; + let result = CairoRunner::new(&program, &config); match result { Err(RunnerError::DisableTracePaddingWithoutProofMode) => { /* test passed */ } _ => panic!("Expected DisableTracePaddingWithoutProofMode error"), @@ -5807,8 +5791,7 @@ mod tests { let program: &Program = &program; let mut cairo_runner = - CairoRunner::new(program, LayoutName::plain, None, false, false, false) - .expect("failed to create runner"); + CairoRunner::new(program, &CairoRunConfig::default()).expect("failed to create runner"); // We allow missing builtins, as we will simulate them later. let end = cairo_runner @@ -5836,8 +5819,12 @@ mod tests { Some("main"), ) .unwrap(); - let runner = - CairoRunner::new_stwo(&program, RunnerMode::ProofModeCanonical, true, true).unwrap(); + let runner = CairoRunner::new_stwo( + &program, + &StwoCairoRunConfig::default(), + RunnerMode::ProofModeCanonical, + ) + .unwrap(); assert_eq!(runner.runner_mode, RunnerMode::ProofModeCanonical); assert!(runner.execution_public_memory.is_some()); } @@ -5849,8 +5836,15 @@ mod tests { Some("main"), ) .unwrap(); - let runner = - CairoRunner::new_stwo(&program, RunnerMode::ExecutionMode, true, false).unwrap(); + let runner = CairoRunner::new_stwo( + &program, + &StwoCairoRunConfig { + disable_trace_padding: false, + ..Default::default() + }, + RunnerMode::ExecutionMode, + ) + .unwrap(); assert_eq!(runner.runner_mode, RunnerMode::ExecutionMode); assert!(runner.execution_public_memory.is_none()); } @@ -5858,7 +5852,11 @@ mod tests { #[test] fn new_stwo_disable_trace_padding_without_proof_mode() { let program = Program::default(); - match CairoRunner::new_stwo(&program, RunnerMode::ExecutionMode, true, true) { + match CairoRunner::new_stwo( + &program, + &StwoCairoRunConfig::default(), + RunnerMode::ExecutionMode, + ) { Err(RunnerError::DisableTracePaddingWithoutProofMode) => {} _ => panic!("Expected DisableTracePaddingWithoutProofMode error"), } @@ -5871,8 +5869,12 @@ mod tests { Some("main"), ) .unwrap(); - let mut runner = - CairoRunner::new_stwo(&program, RunnerMode::ProofModeCanonical, true, true).unwrap(); + let mut runner = CairoRunner::new_stwo( + &program, + &StwoCairoRunConfig::default(), + RunnerMode::ProofModeCanonical, + ) + .unwrap(); let allowed = vec![ BuiltinName::output, BuiltinName::pedersen, @@ -5895,8 +5897,12 @@ mod tests { #[test] fn initialize_builtins_stwo_rejects_ecdsa() { let program = Program::default(); - let mut runner = - CairoRunner::new_stwo(&program, RunnerMode::ProofModeCanonical, true, true).unwrap(); + let mut runner = CairoRunner::new_stwo( + &program, + &StwoCairoRunConfig::default(), + RunnerMode::ProofModeCanonical, + ) + .unwrap(); match runner.initialize_builtins_stwo(&[BuiltinName::ecdsa]) { Err(RunnerError::UnsupportedStwoBuiltin(BuiltinName::ecdsa)) => {} _ => panic!("Expected UnsupportedStwoBuiltin(ecdsa) error"), @@ -5906,8 +5912,12 @@ mod tests { #[test] fn initialize_builtins_stwo_rejects_keccak() { let program = Program::default(); - let mut runner = - CairoRunner::new_stwo(&program, RunnerMode::ProofModeCanonical, true, true).unwrap(); + let mut runner = CairoRunner::new_stwo( + &program, + &StwoCairoRunConfig::default(), + RunnerMode::ProofModeCanonical, + ) + .unwrap(); match runner.initialize_builtins_stwo(&[BuiltinName::keccak]) { Err(RunnerError::UnsupportedStwoBuiltin(BuiltinName::keccak)) => {} _ => panic!("Expected UnsupportedStwoBuiltin(keccak) error"), @@ -5921,8 +5931,12 @@ mod tests { Some("main"), ) .unwrap(); - let mut runner = - CairoRunner::new_stwo(&program, RunnerMode::ProofModeCanonical, true, true).unwrap(); + let mut runner = CairoRunner::new_stwo( + &program, + &StwoCairoRunConfig::default(), + RunnerMode::ProofModeCanonical, + ) + .unwrap(); // bitwise_builtin_test requires bitwise, but we only allow output match runner.initialize_builtins_stwo(&[BuiltinName::output]) { Err(RunnerError::UnsupportedStwoBuiltin(BuiltinName::bitwise)) => {}