diff --git a/cairo-vm-cli/src/main.rs b/cairo-vm-cli/src/main.rs index 33036b7855..0b39884b2a 100644 --- a/cairo-vm-cli/src/main.rs +++ b/cairo-vm-cli/src/main.rs @@ -69,9 +69,10 @@ struct Args { conflicts_with_all = ["proof_mode", "air_private_input", "air_public_input"] )] cairo_pie_output: Option, - #[arg(long = "prover_input_info", - requires_all = ["proof_mode"])] + #[arg(long = "prover_input_info", requires_all = ["proof_mode"])] prover_input_info: Option, + #[arg(long = "prover_input_info_json", requires_all = ["proof_mode"])] + prover_input_info_json: Option, #[arg(long = "merge_extra_segments")] merge_extra_segments: bool, #[arg(long = "allow_missing_builtins")] @@ -175,7 +176,8 @@ fn run(args: impl Iterator) -> Result<(), Error> { let trace_enabled = args.trace_file.is_some() || args.air_public_input.is_some() - || args.prover_input_info.is_some(); + || args.prover_input_info.is_some() + || args.prover_input_info_json.is_some(); let cairo_layout_params = match args.cairo_layout_params_file { Some(file) => Some(CairoLayoutParams::from_file(&file)?), @@ -191,7 +193,8 @@ fn run(args: impl Iterator) -> Result<(), Error> { secure_run: args.secure_run, allow_missing_builtins: args.allow_missing_builtins, dynamic_layout_params: cairo_layout_params, - disable_trace_padding: args.prover_input_info.is_some(), + disable_trace_padding: args.prover_input_info.is_some() + || args.prover_input_info_json.is_some(), }; let mut cairo_runner = match if args.run_from_cairo_pie { @@ -242,13 +245,22 @@ fn run(args: impl Iterator) -> Result<(), Error> { memory_writer.flush()?; } - if let Some(prover_input_info_path) = args.prover_input_info { + if let Some(path) = args.prover_input_info { + let prover_input_info = cairo_runner.get_prover_input_info().map_err(|error| { + eprintln!("{error}"); + CairoRunError::Runner(error) + })?; + let bytes = prover_input_info.serialize()?; + std::fs::write(path, bytes)?; + } + + if let Some(path) = args.prover_input_info_json { let prover_input_info = cairo_runner.get_prover_input_info().map_err(|error| { eprintln!("{error}"); CairoRunError::Runner(error) })?; let json = prover_input_info.serialize_json()?; - std::fs::write(prover_input_info_path, json)?; + std::fs::write(path, json)?; } if let Some(file_path) = args.air_public_input { diff --git a/vm/Cargo.toml b/vm/Cargo.toml index be960a993c..16171d422e 100644 --- a/vm/Cargo.toml +++ b/vm/Cargo.toml @@ -47,7 +47,7 @@ num-integer = { workspace = true } serde = { workspace = true } serde_json = { workspace = true } hex = { workspace = true } -bincode = { workspace = true } +bincode = { workspace = true , features = ["alloc"]} starknet-crypto = { workspace = true } sha3 = { workspace = true } indoc = { workspace = true } diff --git a/vm/src/vm/runners/cairo_runner.rs b/vm/src/vm/runners/cairo_runner.rs index da4854066a..1990cd8329 100644 --- a/vm/src/vm/runners/cairo_runner.rs +++ b/vm/src/vm/runners/cairo_runner.rs @@ -1551,7 +1551,7 @@ impl CairoRunner { //* ---------------------- /// This struct contains all relevant data for the prover. /// All addresses are relocatable. -#[derive(Deserialize, Serialize)] +#[derive(Deserialize, Serialize, PartialEq)] pub struct ProverInputInfo { /// A vector of trace entries, i.e. pc, ap, fp, where pc is relocatable. pub relocatable_trace: Vec, @@ -1567,13 +1567,19 @@ impl ProverInputInfo { pub fn serialize_json(&self) -> Result { serde_json::to_string_pretty(&self).map_err(ProverInputInfoError::from) } + pub fn serialize(&self) -> Result, ProverInputInfoError> { + bincode::serde::encode_to_vec(self, bincode::config::standard()) + .map_err(ProverInputInfoError::from) + } } // TODO(Stav): add TraceNotEnabled error. #[derive(Debug, Error)] pub enum ProverInputInfoError { - #[error("Failed to (de)serialize data")] - Serde(#[from] serde_json::Error), + #[error("Failed to (de)serialize data using bincode")] + SerdeBincode(#[from] bincode::error::EncodeError), + #[error("Failed to (de)serialize data using json")] + SerdeJson(#[from] serde_json::Error), } #[derive(Clone, Debug, Eq, PartialEq)] @@ -5708,25 +5714,29 @@ mod tests { }; let runner = crate::cairo_run::cairo_run(program_content, &config, &mut crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor::new_empty()).unwrap(); let prover_input_info = runner.get_prover_input_info().unwrap(); - let serialized_prover_input_info = prover_input_info.serialize_json().unwrap(); - let deserialized_prover_input_info: ProverInputInfo = - serde_json::from_str(&serialized_prover_input_info).unwrap(); - // Check that the deserialized prover input info is equal to the original one. - assert_eq!( - prover_input_info.relocatable_memory, - deserialized_prover_input_info.relocatable_memory - ); - assert_eq!( - prover_input_info.relocatable_trace, - deserialized_prover_input_info.relocatable_trace - ); - assert_eq!( - prover_input_info.builtins_segments, - deserialized_prover_input_info.builtins_segments + + // Using bincode. + let serialized_prover_input_info = prover_input_info.serialize().unwrap(); + let (deserialized_prover_input_info, _): (ProverInputInfo, usize) = + bincode::serde::decode_from_slice( + &serialized_prover_input_info, + bincode::config::standard(), + ) + .unwrap(); + + assert!( + prover_input_info == deserialized_prover_input_info, + "Deserialized ProverInputInfo with bincode does not match the original one." ); - assert_eq!( - prover_input_info.public_memory_offsets, - deserialized_prover_input_info.public_memory_offsets + + // Using json. + let serialized_prover_input_info_json = prover_input_info.serialize_json().unwrap(); + let deserialized_prover_input_info_json: ProverInputInfo = + serde_json::from_str(&serialized_prover_input_info_json).unwrap(); + + assert!( + prover_input_info == deserialized_prover_input_info_json, + "Deserialized ProverInputInfo with json does not match the original one." ); } }