[DNM] Starkware Development

CHANGELOG.md

@@ -1,6 +1,11 @@
 ## Cairo-VM Changelog
 
 #### Upcoming Changes
+* 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)
 
 * fix: Always use a normal segment in first SegmentArena segment [#1845](https://github.com/lambdaclass/cairo-vm/pull/1845)
 
@@ -28,6 +33,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 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 @@
         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 @@
     #[error(transparent)]
     PublicInput(#[from] PublicInputError),
     #[error(transparent)]
+    ProveInputInfo(#[from] ProverInputInfoError),
+    #[error(transparent)]
     #[cfg(feature = "with_tracer")]
     TraceData(#[from] TraceDataError),
 }
@@ -168,7 +175,10 @@
 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)?),
@@ -184,7 +194,8 @@
         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 {
@@ -235,6 +246,24 @@
         memory_writer.flush()?;
     }
 
+    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(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)?;
@@ -358,6 +387,7 @@
         #[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 {
@@ -388,11 +418,15 @@
         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);

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

@@ -103,9 +103,9 @@
         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()?;
@@ -208,9 +208,9 @@
         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 {
@@ -258,9 +258,8 @@
 
     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()?;

vm/src/hint_processor/builtin_hint_processor/blake2s_utils.rs

@@ -1,3 +1,4 @@
+use crate::hint_processor::hint_processor_utils::felt_to_usize;
 use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*};
 
 use crate::types::errors::math_errors::MathError;
@@ -17,9 +18,11 @@ use crate::{
     vm::{errors::hint_errors::HintError, vm_core::VirtualMachine},
 };
 
+use num_bigint::BigUint;
+use num_integer::Integer;
 use num_traits::ToPrimitive;
 
-use super::hint_utils::get_integer_from_var_name;
+use super::hint_utils::{get_integer_from_var_name, insert_value_into_ap};
 
 fn get_fixed_size_u32_array<const T: usize>(
     h_range: &Vec<Cow<Felt252>>,
@@ -242,6 +245,84 @@ pub fn blake2s_add_uint256_bigend(
     Ok(())
 }
 
+/* Implements Hint:
+memory[ap] = (ids.end != ids.packed_values) and (memory[ids.packed_values] < 2**63)
+*/
+pub fn is_less_than_63_bits_and_not_end(
+    vm: &mut VirtualMachine,
+    ids_data: &HashMap<String, HintReference>,
+    ap_tracking: &ApTracking,
+) -> Result<(), HintError> {
+    let end = get_ptr_from_var_name("end", vm, ids_data, ap_tracking)?;
+    let packed_values = get_ptr_from_var_name("packed_values", vm, ids_data, ap_tracking)?;
+
+    if end == packed_values {
+        insert_value_into_ap(vm, 0)?
+    } else {
+        let val = vm.get_integer(packed_values)?;
+        insert_value_into_ap(
+            vm,
+            (val.to_biguint() < (BigUint::from(1_u32) << 63)) as usize,
+        )?
+    }
+    Ok(())
+}
+
+/* Implements Hint:
+offset = 0
+for i in range(ids.packed_values_len):
+    val = (memory[ids.packed_values + i] % PRIME)
+    val_len = 2 if val < 2**63 else 8
+    if val_len == 8:
+        val += 2**255
+    for i in range(val_len - 1, -1, -1):
+        val, memory[ids.unpacked_u32s + offset + i] = divmod(val, 2**32)
+    assert val == 0
+    offset += val_len
+*/
+pub fn blake2s_unpack_felts(
+    vm: &mut VirtualMachine,
+    ids_data: &HashMap<String, HintReference>,
+    ap_tracking: &ApTracking,
+) -> Result<(), HintError> {
+    let packed_values_len =
+        get_integer_from_var_name("packed_values_len", vm, ids_data, ap_tracking)?;
+    let packed_values = get_ptr_from_var_name("packed_values", vm, ids_data, ap_tracking)?;
+    let unpacked_u32s = get_ptr_from_var_name("unpacked_u32s", vm, ids_data, ap_tracking)?;
+
+    let vals = vm.get_integer_range(packed_values, felt_to_usize(&packed_values_len)?)?;
+    let pow2_32 = BigUint::from(1_u32) << 32;
+    let pow2_63 = BigUint::from(1_u32) << 63;
+    let pow2_255 = BigUint::from(1_u32) << 255;
+
+    // Split value into either 2 or 8 32-bit limbs.
+    let out: Vec<MaybeRelocatable> = vals
+        .into_iter()
+        .map(|val| val.to_biguint())
+        .flat_map(|val| {
+            if val < pow2_63 {
+                let (high, low) = val.div_rem(&pow2_32);
+                vec![high, low]
+            } else {
+                let mut limbs = vec![BigUint::from(0_u32); 8];
+                let mut val: BigUint = val + &pow2_255;
+                for limb in limbs.iter_mut().rev() {
+                    let (q, r) = val.div_rem(&pow2_32);
+                    *limb = r;
+                    val = q;
+                }
+                limbs
+            }
+        })
+        .map(Felt252::from)
+        .map(MaybeRelocatable::from)
+        .collect();
+
+    vm.load_data(unpacked_u32s, &out)
+        .map_err(HintError::Memory)?;
+    Ok(())
+}
+
 /* Implements Hint:
     %{
         from starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress
@@ -604,6 +685,103 @@ mod tests {
             .is_none());
     }
 
+    #[test]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
+    fn is_less_than_63_bits_and_not_end_ends() {
+        let hint_code = hint_code::IS_LESS_THAN_63_BITS_AND_NOT_END;
+        //Create vm
+        let mut vm = vm!();
+        //Insert ids into memory
+        vm.segments = segments![((1, 0), (1, 2)), ((1, 1), (1, 2)), ((1, 2), 123)];
+        vm.set_fp(3);
+        vm.set_ap(3);
+        let ids_data = ids_data!["end", "packed_values", "value"];
+        //Execute the hint
+        assert_matches!(run_hint!(vm, ids_data, hint_code), Ok(()));
+        //Check data ptr
+        check_memory![vm.segments.memory, ((1, 3), 0)];
+    }
+
+    #[test]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
+    fn is_less_than_63_bits_and_not_end_small() {
+        let hint_code = hint_code::IS_LESS_THAN_63_BITS_AND_NOT_END;
+        //Create vm
+        let mut vm = vm!();
+        //Insert ids into memory
+        vm.segments = segments![((1, 0), (1, 3)), ((1, 1), (1, 2)), ((1, 2), 123)];
+        vm.set_fp(3);
+        vm.set_ap(3);
+        let ids_data = ids_data!["end", "packed_values", "value"];
+        //Execute the hint
+        assert_matches!(run_hint!(vm, ids_data, hint_code), Ok(()));
+        //Check data ptr
+        check_memory![vm.segments.memory, ((1, 3), 1)];
+    }
+
+    #[test]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
+    fn is_less_than_63_bits_and_not_end_big() {
+        let hint_code = hint_code::IS_LESS_THAN_63_BITS_AND_NOT_END;
+        //Create vm
+        let mut vm = vm!();
+        //Insert ids into memory
+        vm.segments = segments![
+            ((1, 0), (1, 3)),
+            ((1, 1), (1, 2)),
+            ((1, 2), 0x10000000000000000)
+        ];
+        vm.set_fp(3);
+        vm.set_ap(3);
+        let ids_data = ids_data!["end", "packed_values", "value"];
+        //Execute the hint
+        assert_matches!(run_hint!(vm, ids_data, hint_code), Ok(()));
+        //Check data ptr
+        check_memory![vm.segments.memory, ((1, 3), 0)];
+    }
+
+    #[test]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
+    fn blake2s_unpack_felts() {
+        let hint_code = hint_code::BLAKE2S_UNPACK_FELTS;
+        //Create vm
+        let mut vm = vm!();
+        //Insert ids into memory
+        vm.segments = segments![
+            ((1, 0), 2),
+            ((1, 1), (1, 3)),
+            ((1, 2), (2, 0)),
+            ((1, 3), 0x123456781234),
+            ((1, 4), 0x1234abcd5678efab1234abcd)
+        ];
+        vm.set_fp(5);
+        vm.set_ap(5);
+        let ids_data = ids_data![
+            "packed_values_len",
+            "packed_values",
+            "unpacked_u32s",
+            "small_value",
+            "big_value"
+        ];
+        vm.segments.add();
+        //Execute the hint
+        assert_matches!(run_hint!(vm, ids_data, hint_code), Ok(()));
+        //Check data ptr
+        check_memory![
+            vm.segments.memory,
+            ((2, 0), 0x1234),
+            ((2, 1), 0x56781234),
+            ((2, 2), 0x80000000),
+            ((2, 3), 0),
+            ((2, 4), 0),
+            ((2, 5), 0),
+            ((2, 6), 0),
+            ((2, 7), 0x1234abcd),
+            ((2, 8), 0x5678efab),
+            ((2, 9), 0x1234abcd)
+        ];
+    }
+
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn blake2s_add_uint256_bigend_valid_non_zero() {