[DNM] starkware-development synced with 2.x.y

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 #### Upcoming Changes
 
+* chore: Pin types-rs version to the one set in lockfile [#2140](https://github.com/lambdaclass/cairo-vm/pull/2140)
+
+*  BREAKING CHANGE: `get_prover_input_info()` now requires `&mut self` and takes ownershop on the trace instead of cloning it. [#2127](https://github.com/lambdaclass/cairo-vm/pull/2127)
+
+* Refactor: Replaced HashMap with BTreeMap to guarantee deterministic ordering of the data [#2023] (https://github.com/lambdaclass/cairo-vm/pull/2023)
+
+* fix: Updated the logic for collecting builtin segment data for prover input info, removing dependency on the existence of stop pointers. [#2022](https://github.com/lambdaclass/cairo-vm/pull/2022)
+
+* fix: Keep None values in memory segments for the prover input info [#2021](https://github.com/lambdaclass/cairo-vm/pull/2021)
+
 #### [2.3.1] - 2025-07-29
 
 * chore: Pin types-rs version to 0.1.8 [#2146](https://github.com/lambdaclass/cairo-vm/pull/2146)
@@ -58,6 +68,8 @@
 
 * feat: Add `ProverInfo` and extract the relevant information for it from the runner [#2001](https://github.com/lambdaclass/cairo-vm/pull/2001)
 
+* feat: Support hints for new blake felt serialization library code [#1994](https://github.com/lambdaclass/cairo-vm/pull/1994)
+
 #### [2.0.1] - 2025-03-17
 
 * feat: Limited padding of builtin segments to >=16 [#1981](https://github.com/lambdaclass/cairo-vm/pull/1981)

cairo-vm-cli/src/main.rs

@@ -4,6 +4,7 @@ use bincode::enc::write::Writer;
 use cairo_vm::air_public_input::PublicInputError;
 use cairo_vm::cairo_run::{self, EncodeTraceError};
 use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor;
+use cairo_vm::prover_input_info::ProverInputInfoError;
 #[cfg(feature = "with_tracer")]
 use cairo_vm::serde::deserialize_program::DebugInfo;
 use cairo_vm::types::layout::CairoLayoutParams;
@@ -69,6 +70,10 @@ struct Args {
         conflicts_with_all = ["proof_mode", "air_private_input", "air_public_input"]
     )]
     cairo_pie_output: Option<String>,
+    #[arg(long = "prover_input_info", requires_all = ["proof_mode"])]
+    prover_input_info: Option<String>,
+    #[arg(long = "prover_input_info_json", requires_all = ["proof_mode"])]
+    prover_input_info_json: Option<String>,
     #[arg(long = "merge_extra_segments")]
     merge_extra_segments: bool,
     #[arg(long = "allow_missing_builtins")]
@@ -102,6 +107,8 @@ enum Error {
     #[error(transparent)]
     PublicInput(#[from] PublicInputError),
     #[error(transparent)]
+    ProveInputInfo(#[from] ProverInputInfoError),
+    #[error(transparent)]
     #[cfg(feature = "with_tracer")]
     TraceData(#[from] TraceDataError),
 }
@@ -169,7 +176,10 @@ fn start_tracer(cairo_runner: &CairoRunner) -> Result<(), TraceDataError> {
 fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
     let args = Args::try_parse_from(args)?;
 
-    let trace_enabled = args.trace_file.is_some() || args.air_public_input.is_some();
+    let trace_enabled = args.trace_file.is_some()
+        || args.air_public_input.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)?),
@@ -180,12 +190,14 @@ fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
         entrypoint: &args.entrypoint,
         trace_enabled,
         relocate_mem: args.memory_file.is_some() || args.air_public_input.is_some(),
+        relocate_trace: trace_enabled,
         layout: args.layout,
         proof_mode: args.proof_mode,
         secure_run: args.secure_run,
         allow_missing_builtins: args.allow_missing_builtins,
         dynamic_layout_params: cairo_layout_params,
-        ..Default::default()
+        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 {
@@ -236,6 +248,18 @@ fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
         memory_writer.flush()?;
     }
 
+    if let Some(path) = args.prover_input_info {
+        let prover_input_info = cairo_runner.get_prover_input_info()?;
+        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()?;
+        let json = prover_input_info.serialize_json()?;
+        std::fs::write(path, json)?;
+    }
+
     if let Some(file_path) = args.air_public_input {
         let json = cairo_runner.get_air_public_input()?.serialize_json()?;
         std::fs::write(file_path, json)?;
@@ -360,6 +384,7 @@ mod tests {
         #[values(false, true)] air_public_input: bool,
         #[values(false, true)] air_private_input: bool,
         #[values(false, true)] cairo_pie_output: bool,
+        #[values(false, true)] prover_input_info: bool,
     ) {
         let mut args = vec!["cairo-vm-cli".to_string()];
         if let Some(layout) = layout {
@@ -390,11 +415,15 @@ mod tests {
         if print_output {
             args.extend_from_slice(&["--print_output".to_string()]);
         }
+        if prover_input_info {
+            args.extend_from_slice(&["--prover_input_info".to_string(), "/dev/null".to_string()]);
+        }
 
         args.push("../cairo_programs/proof_programs/fibonacci.json".to_string());
         if air_public_input && !proof_mode
             || (air_private_input && (!proof_mode || !trace_file || !memory_file))
             || cairo_pie_output && proof_mode
+            || prover_input_info && !proof_mode
         {
             assert_matches!(run(args.into_iter()), Err(_));
         } else {

cairo1-run/src/cairo_run.rs

@@ -267,7 +267,12 @@ pub fn cairo_run_program(
         runner.run_for_steps(1, &mut hint_processor)?;
     }
 
-    runner.end_run(false, false, &mut hint_processor)?;
+    runner.end_run(
+        false,
+        false,
+        &mut hint_processor,
+        cairo_run_config.proof_mode,
+    )?;
 
     let result_inner_type_size =
         result_inner_type_size(return_type_id, &sierra_program_registry, &type_sizes);
@@ -336,7 +341,7 @@ pub fn cairo_run_program(
         }
     }
 
-    runner.relocate(true)?;
+    runner.relocate(true, true)?;
 
     Ok((runner, return_values, serialized_output))
 }

cairo_programs/poseidon_builtin_hole.cairo

@@ -0,0 +1,12 @@
+%builtins poseidon
+from starkware.cairo.common.cairo_builtins import PoseidonBuiltin
+from starkware.cairo.common.poseidon_state import PoseidonBuiltinState
+
+func main{poseidon_ptr: PoseidonBuiltin*}() {
+    assert poseidon_ptr[0].input = PoseidonBuiltinState(1, 2, 3);
+    let result = poseidon_ptr[0].output;
+    let poseidon_ptr = poseidon_ptr + PoseidonBuiltin.SIZE;
+    assert result.s0 = 442682200349489646213731521593476982257703159825582578145778919623645026501;
+    assert result.s2 = 2512222140811166287287541003826449032093371832913959128171347018667852712082;
+    return ();
+}

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 }

vm/src/cairo_run.rs

@@ -27,7 +27,10 @@ pub struct CairoRunConfig<'a> {
     #[cfg_attr(feature = "test_utils", arbitrary(value = "main"))]
     pub entrypoint: &'a str,
     pub trace_enabled: bool,
+    /// Relocate memory if `true`, otherwise memory is not relocated.
     pub relocate_mem: bool,
+    // When `relocate_trace` is set to `false`, the trace will not be relocated even if `trace_enabled` is `true`.
+    pub relocate_trace: bool,
     pub layout: LayoutName,
     /// The `dynamic_layout_params` argument should only be used with dynamic layout.
     /// It is ignored otherwise.
@@ -51,6 +54,8 @@ impl Default for CairoRunConfig<'_> {
             entrypoint: "main",
             trace_enabled: false,
             relocate_mem: false,
+            // Set to true to match expected behavior: trace is relocated only if trace_enabled is true.
+            relocate_trace: true,
             layout: LayoutName::plain,
             proof_mode: false,
             secure_run: None,
@@ -104,17 +109,20 @@ pub fn cairo_run_program_with_initial_scope(
         cairo_run_config.disable_trace_padding,
         false,
         hint_processor,
+        cairo_run_config.proof_mode,
     )?;
 
-    cairo_runner.vm.verify_auto_deductions()?;
     cairo_runner.read_return_values(allow_missing_builtins)?;
     if cairo_run_config.proof_mode {
         cairo_runner.finalize_segments()?;
     }
     if secure_run {
         verify_secure_runner(&cairo_runner, true, None)?;
     }
-    cairo_runner.relocate(cairo_run_config.relocate_mem)?;
+    cairo_runner.relocate(
+        cairo_run_config.relocate_mem,
+        cairo_run_config.relocate_trace,
+    )?;
 
     Ok(cairo_runner)
 }
@@ -213,17 +221,20 @@ pub fn cairo_run_pie(
         cairo_run_config.disable_trace_padding,
         false,
         hint_processor,
+        cairo_run_config.proof_mode,
     )?;
 
-    cairo_runner.vm.verify_auto_deductions()?;
     cairo_runner.read_return_values(allow_missing_builtins)?;
 
     if secure_run {
         verify_secure_runner(&cairo_runner, true, None)?;
         // Check that the Cairo PIE produced by this run is compatible with the Cairo PIE received
         cairo_runner.get_cairo_pie()?.check_pie_compatibility(pie)?;
     }
-    cairo_runner.relocate(cairo_run_config.relocate_mem)?;
+    cairo_runner.relocate(
+        cairo_run_config.relocate_mem,
+        cairo_run_config.relocate_trace,
+    )?;
 
     Ok(cairo_runner)
 }
@@ -264,17 +275,19 @@ pub fn cairo_run_fuzzed_program(
 
     res.map_err(|err| VmException::from_vm_error(&cairo_runner, err))?;
 
-    cairo_runner.end_run(false, false, hint_processor)?;
+    cairo_runner.end_run(false, false, hint_processor, cairo_run_config.proof_mode)?;
 
-    cairo_runner.vm.verify_auto_deductions()?;
     cairo_runner.read_return_values(allow_missing_builtins)?;
     if cairo_run_config.proof_mode {
         cairo_runner.finalize_segments()?;
     }
     if secure_run {
         verify_secure_runner(&cairo_runner, true, None)?;
     }
-    cairo_runner.relocate(cairo_run_config.relocate_mem)?;
+    cairo_runner.relocate(
+        cairo_run_config.relocate_mem,
+        cairo_run_config.relocate_trace,
+    )?;
 
     Ok(cairo_runner)
 }
@@ -375,7 +388,7 @@ mod tests {
 
         let end = cairo_runner.initialize(false).unwrap();
         assert!(cairo_runner.run_until_pc(end, &mut hint_processor).is_ok());
-        assert!(cairo_runner.relocate(true).is_ok());
+        assert!(cairo_runner.relocate(true, true).is_ok());
         // `main` returns without doing nothing, but `not_main` sets `[ap]` to `1`
         // Memory location was found empirically and simply hardcoded
         assert_eq!(cairo_runner.relocated_memory[2], Some(Felt252::from(123)));
@@ -441,7 +454,7 @@ mod tests {
         let mut hint_processor = BuiltinHintProcessor::new_empty();
         let mut cairo_runner = run_test_program(program_content, &mut hint_processor).unwrap();
 
-        assert!(cairo_runner.relocate(false).is_ok());
+        assert!(cairo_runner.relocate(false, true).is_ok());
 
         let trace_entries = cairo_runner.relocated_trace.unwrap();
         let mut buffer = [0; 24];
@@ -465,7 +478,7 @@ mod tests {
         let mut cairo_runner = run_test_program(program_content, &mut hint_processor).unwrap();
 
         // relocate memory so we can dump it to file
-        assert!(cairo_runner.relocate(true).is_ok());
+        assert!(cairo_runner.relocate(true, true).is_ok());
 
         let mut buffer = [0; 120];
         let mut buff_writer = SliceWriter::new(&mut buffer);
@@ -489,7 +502,7 @@ mod tests {
         let mut cairo_runner = cairo_runner!(program);
         let end = cairo_runner.initialize(false).unwrap();
         assert!(cairo_runner.run_until_pc(end, &mut hint_processor).is_ok());
-        assert!(cairo_runner.relocate(false).is_ok());
+        assert!(cairo_runner.relocate(false, false).is_ok());
         assert!(cairo_runner.relocated_trace.is_none());
     }