Fix_zero_offset_output_base_assumption (#2068)

Author: YairVaknin-starkware

cairo-vm-cli/src/main.rs

@@ -72,6 +72,9 @@ struct Args {
     #[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")]
@@ -175,7 +178,8 @@ fn run(args: impl Iterator<Item = String>) -> 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 +195,8 @@ fn run(args: impl Iterator<Item = String>) -> 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 +247,22 @@ fn run(args: impl Iterator<Item = String>) -> 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 {

vm/src/vm/runners/builtin_runner/output.rs

@@ -12,13 +12,15 @@ use crate::vm::vm_memory::memory_segments::MemorySegmentManager;
 #[derive(Debug, Clone, PartialEq)]
 pub struct OutputBuiltinState {
     pub base: usize,
+    pub base_offset: usize,
     pub pages: Pages,
     pub attributes: Attributes,
 }
 
 #[derive(Debug, Clone)]
 pub struct OutputBuiltinRunner {
     base: usize,
+    pub base_offset: usize,
     pub(crate) pages: Pages,
     pub(crate) attributes: Attributes,
     pub(crate) stop_ptr: Option<usize>,
@@ -29,15 +31,17 @@ impl OutputBuiltinRunner {
     pub fn new(included: bool) -> OutputBuiltinRunner {
         OutputBuiltinRunner {
             base: 0,
+            base_offset: 0,
             pages: HashMap::default(),
             attributes: HashMap::default(),
             stop_ptr: None,
             included,
         }
     }
 
-    pub fn new_state(&mut self, base: usize, included: bool) {
+    pub fn new_state(&mut self, base: usize, base_offset: usize, included: bool) {
         self.base = base;
+        self.base_offset = base_offset;
         self.pages = HashMap::default();
         self.attributes = HashMap::default();
         self.stop_ptr = None;
@@ -143,13 +147,15 @@ impl OutputBuiltinRunner {
 
     pub fn set_state(&mut self, new_state: OutputBuiltinState) {
         self.base = new_state.base;
+        self.base_offset = new_state.base_offset;
         self.pages = new_state.pages;
         self.attributes = new_state.attributes;
     }
 
     pub fn get_state(&mut self) -> OutputBuiltinState {
         OutputBuiltinState {
             base: self.base,
+            base_offset: self.base_offset,
             pages: self.pages.clone(),
             attributes: self.attributes.clone(),
         }
@@ -168,7 +174,7 @@ impl OutputBuiltinRunner {
         self.pages.insert(
             page_id,
             PublicMemoryPage {
-                start: page_start.offset,
+                start: page_start.offset - self.base_offset,
                 size: page_size,
             },
         );
@@ -493,6 +499,7 @@ mod tests {
 
         let new_state = OutputBuiltinState {
             base: 10,
+            base_offset: 0,
             pages: HashMap::from([(1, PublicMemoryPage { start: 0, size: 3 })]),
             attributes: HashMap::from([("gps_fact_topology".to_string(), vec![0, 2, 0])]),
         };
@@ -510,6 +517,7 @@ mod tests {
     fn new_state() {
         let mut builtin = OutputBuiltinRunner {
             base: 10,
+            base_offset: 0,
             pages: HashMap::from([(1, PublicMemoryPage { start: 0, size: 3 })]),
             attributes: HashMap::from([("gps_fact_topology".to_string(), vec![0, 2, 0])]),
             stop_ptr: Some(10),
@@ -518,9 +526,10 @@ mod tests {
 
         let new_base = 11;
         let new_included = false;
-        builtin.new_state(new_base, new_included);
+        builtin.new_state(new_base, 2, new_included);
 
         assert_eq!(builtin.base, new_base);
+        assert_eq!(builtin.base_offset, 2);
         assert!(builtin.pages.is_empty());
         assert!(builtin.attributes.is_empty());
         assert_eq!(builtin.stop_ptr, None);
@@ -614,6 +623,7 @@ mod tests {
     fn get_and_extend_additional_data() {
         let builtin_a = OutputBuiltinRunner {
             base: 0,
+            base_offset: 0,
             pages: HashMap::from([(1, PublicMemoryPage { start: 0, size: 3 })]),
             attributes: HashMap::from([("gps_fact_topology".to_string(), vec![0, 2, 0])]),
             stop_ptr: None,
@@ -622,6 +632,7 @@ mod tests {
         let additional_data = builtin_a.get_additional_data();
         let mut builtin_b = OutputBuiltinRunner {
             base: 0,
+            base_offset: 0,
             pages: Default::default(),
             attributes: Default::default(),
             stop_ptr: None,

vm/src/vm/runners/cairo_runner.rs

@@ -1567,13 +1567,19 @@ impl ProverInputInfo {
     pub fn serialize_json(&self) -> Result<String, ProverInputInfoError> {
         serde_json::to_string_pretty(&self).map_err(ProverInputInfoError::from)
     }
+    pub fn serialize(&self) -> Result<Vec<u8>, ProverInputInfoError> {
+        bincode::serde::encode_to_vec(self, bincode::config::standard())
+            .map_err(|e| ProverInputInfoError::SerializationError(format!("{:?}", e)))
+    }
 }
 
 // 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")]
+    SerializationError(String),
+    #[error("Failed to (de)serialize data using json")]
+    SerdeJson(#[from] serde_json::Error),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -5699,6 +5705,16 @@ mod tests {
     fn serialize_and_deserialize_prover_input_info(#[case] program_content: &[u8]) {
         use crate::types::layout_name::LayoutName;
 
+        fn compare_prover_input_info(original: &ProverInputInfo, deserialized: &ProverInputInfo) {
+            assert_eq!(original.relocatable_memory, deserialized.relocatable_memory);
+            assert_eq!(original.relocatable_trace, deserialized.relocatable_trace);
+            assert_eq!(original.builtins_segments, deserialized.builtins_segments);
+            assert_eq!(
+                original.public_memory_offsets,
+                deserialized.public_memory_offsets
+            );
+        }
+
         let config = crate::cairo_run::CairoRunConfig {
             proof_mode: false,
             relocate_mem: false,
@@ -5708,25 +5724,25 @@ 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();
+
+        // 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();
+
         // 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
-        );
-        assert_eq!(
-            prover_input_info.public_memory_offsets,
-            deserialized_prover_input_info.public_memory_offsets
-        );
+        compare_prover_input_info(&prover_input_info, &deserialized_prover_input_info);
+
+        // 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();
+
+        // Check that the deserialized prover input info is equal to the original one.
+        compare_prover_input_info(&prover_input_info, &deserialized_prover_input_info_json);
     }
 }