[DNM] Starkware Development

.github/workflows/rust.yml

@@ -642,6 +642,37 @@ jobs:
         key: codecov-cache-test-no_std-mod_builtin-${{ github.sha }}
         fail-on-cache-miss: true
 
+    - name: Fetch results for tests with stdlib (w/cairo-0-secp-hints; part. 1)
+      uses: actions/cache/restore@v3
+      with:
+        path: lcov-test#1-cairo-0-secp-hints.info
+        key: codecov-cache-test#1-cairo-0-secp-hints-${{ github.sha }}
+        fail-on-cache-miss: true
+    - name: Fetch results for tests with stdlib (w/cairo-0-secp-hints; part. 2)
+      uses: actions/cache/restore@v3
+      with:
+        path: lcov-test#2-cairo-0-secp-hints.info
+        key: codecov-cache-test#2-cairo-0-secp-hints-${{ github.sha }}
+        fail-on-cache-miss: true
+    - name: Fetch results for tests with stdlib (w/cairo-0-secp-hints; part. 3)
+      uses: actions/cache/restore@v3
+      with:
+        path: lcov-test#3-cairo-0-secp-hints.info
+        key: codecov-cache-test#3-cairo-0-secp-hints-${{ github.sha }}
+        fail-on-cache-miss: true
+    - name: Fetch results for tests with stdlib (w/cairo-0-secp-hints; part. 4)
+      uses: actions/cache/restore@v3
+      with:
+        path: lcov-test#4-cairo-0-secp-hints.info
+        key: codecov-cache-test#4-cairo-0-secp-hints-${{ github.sha }}
+        fail-on-cache-miss: true
+    - name: Fetch results for tests without stdlib (w/cairo-0-secp-hints)
+      uses: actions/cache/restore@v3
+      with:
+        path: lcov-no_std-cairo-0-secp-hints.info
+        key: codecov-cache-test-no_std-cairo-0-secp-hints-${{ github.sha }}
+        fail-on-cache-miss: true
+
     - name: Upload coverage to codecov.io
       uses: codecov/codecov-action@v3
       with:

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,18 @@
         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)?;
@@ -358,6 +381,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 +412,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);

cairo_programs/cairo-0-secp-hints-feature/negative_points.cairo

@@ -0,0 +1,167 @@
+%builtins range_check
+
+from starkware.cairo.common.secp256r1.ec import (
+    EcPoint,
+)
+from starkware.cairo.common.secp256r1.bigint import nondet_bigint3
+from starkware.cairo.common.cairo_secp.bigint3 import BigInt3
+
+func main{range_check_ptr: felt}() {
+    let point = EcPoint(
+        BigInt3(1, 2, 3),
+        BigInt3(-1, -2, -3),
+    );
+
+    let slope = compute_doubling_slope_prime(point);
+    assert slope = BigInt3(
+        15487438216801236710343013, 27596288489803578791625491, 8178446608657045587339469
+    );
+
+    let slope = compute_doubling_slope_secp256r1(point);
+    assert slope = BigInt3(
+        56511396263956479754791421, 38561311687768998103117219, 2015104701319196654781984
+    );
+
+    let x = BigInt3(-1,-2,-3);
+    let y = try_get_point_from_x_prime(x, 0);
+    assert y = BigInt3(
+        39197606747300743094893670, 38008389934708701866119639, 2071781356858789560884686
+    );
+
+    let x = BigInt3(-1,-2,-3);
+    let y = try_get_point_from_x_secp256r1(x, 0);
+    assert y = BigInt3(
+        56004882917990234964232380, 17943756516348761157632108, 3811440313376405071875160
+    );
+
+    let slope = BigInt3(-1,-2,-3);
+    let x = ec_double_x_prime(point, slope);
+    assert x = BigInt3(
+        648518346341351470, 77370588372549613637288996, 18662792551970020321619971
+    );
+
+    let slope = BigInt3(-1,-2,-3);
+    let x = ec_double_x_secp256r1(point, slope);
+    assert x = BigInt3(
+        21299552074028835321108137, 50187220174510023990904347, 2291813387120727975022296
+    );
+
+    return ();
+}
+
+func compute_doubling_slope_prime{range_check_ptr}(point: EcPoint) -> BigInt3 {
+    %{
+        from starkware.cairo.common.cairo_secp.secp256r1_utils import SECP256R1_ALPHA, SECP256R1_P
+        from starkware.cairo.common.cairo_secp.secp_utils import pack
+        from starkware.python.math_utils import ec_double_slope
+
+        # Compute the slope.
+        x = pack(ids.point.x, PRIME)
+        y = pack(ids.point.y, PRIME)
+        value = slope = ec_double_slope(point=(x, y), alpha=SECP256R1_ALPHA, p=SECP256R1_P)
+    %}
+    let (slope: BigInt3) = nondet_bigint3();
+    return slope;
+}
+
+func compute_doubling_slope_secp256r1{range_check_ptr}(point: EcPoint) -> BigInt3 {
+    %{
+        from starkware.cairo.common.cairo_secp.secp256r1_utils import SECP256R1_ALPHA, SECP256R1_P
+        from starkware.cairo.common.cairo_secp.secp_utils import pack
+        from starkware.python.math_utils import ec_double_slope
+
+        # Compute the slope.
+        x = pack(ids.point.x, SECP256R1_P)
+        y = pack(ids.point.y, SECP256R1_P)
+        value = slope = ec_double_slope(point=(x, y), alpha=SECP256R1_ALPHA, p=SECP256R1_P)
+    %}
+    let (slope: BigInt3) = nondet_bigint3();
+    return slope;
+}
+
+func try_get_point_from_x_prime{range_check_ptr}(x: BigInt3, v: felt) -> BigInt3 {
+    %{
+        from starkware.cairo.common.cairo_secp.secp_utils import SECP256R1, pack
+        from starkware.python.math_utils import y_squared_from_x
+
+        y_square_int = y_squared_from_x(
+            x=pack(ids.x, PRIME),
+            alpha=SECP256R1.alpha,
+            beta=SECP256R1.beta,
+            field_prime=SECP256R1.prime,
+        )
+
+        # Note that (y_square_int ** ((SECP256R1.prime + 1) / 4)) ** 2 =
+        #   = y_square_int ** ((SECP256R1.prime + 1) / 2) =
+        #   = y_square_int ** ((SECP256R1.prime - 1) / 2 + 1) =
+        #   = y_square_int * y_square_int ** ((SECP256R1.prime - 1) / 2) = y_square_int * {+/-}1.
+        y = pow(y_square_int, (SECP256R1.prime + 1) // 4, SECP256R1.prime)
+
+        # We need to decide whether to take y or prime - y.
+        if ids.v % 2 == y % 2:
+            value = y
+        else:
+            value = (-y) % SECP256R1.prime
+    %}
+    let (y: BigInt3) = nondet_bigint3();
+    return y;
+}
+
+func try_get_point_from_x_secp256r1{range_check_ptr}(x: BigInt3, v: felt) -> BigInt3 {
+    %{
+        from starkware.cairo.common.cairo_secp.secp_utils import SECP256R1, pack
+        from starkware.python.math_utils import y_squared_from_x
+
+        y_square_int = y_squared_from_x(
+            x=pack(ids.x, SECP256R1.prime),
+            alpha=SECP256R1.alpha,
+            beta=SECP256R1.beta,
+            field_prime=SECP256R1.prime,
+        )
+
+        # Note that (y_square_int ** ((SECP256R1.prime + 1) / 4)) ** 2 =
+        #   = y_square_int ** ((SECP256R1.prime + 1) / 2) =
+        #   = y_square_int ** ((SECP256R1.prime - 1) / 2 + 1) =
+        #   = y_square_int * y_square_int ** ((SECP256R1.prime - 1) / 2) = y_square_int * {+/-}1.
+        y = pow(y_square_int, (SECP256R1.prime + 1) // 4, SECP256R1.prime)
+
+        # We need to decide whether to take y or prime - y.
+        if ids.v % 2 == y % 2:
+            value = y
+        else:
+            value = (-y) % SECP256R1.prime
+    %}
+    let (y: BigInt3) = nondet_bigint3();
+    return y;
+}
+
+
+func ec_double_x_prime{range_check_ptr}(point: EcPoint, slope: BigInt3) -> BigInt3 {
+    %{
+        from starkware.cairo.common.cairo_secp.secp256r1_utils import SECP256R1_P
+        from starkware.cairo.common.cairo_secp.secp_utils import pack
+
+        slope = pack(ids.slope, PRIME)
+        x = pack(ids.point.x, PRIME)
+        y = pack(ids.point.y, PRIME)
+
+        value = new_x = (pow(slope, 2, SECP256R1_P) - 2 * x) % SECP256R1_P
+    %}
+    let (new_x: BigInt3) = nondet_bigint3();
+    return new_x;
+}
+
+func ec_double_x_secp256r1{range_check_ptr}(point: EcPoint, slope: BigInt3) -> BigInt3 {
+    %{
+        from starkware.cairo.common.cairo_secp.secp256r1_utils import SECP256R1_P
+        from starkware.cairo.common.cairo_secp.secp_utils import pack
+
+        slope = pack(ids.slope, SECP256R1_P)
+        x = pack(ids.point.x, SECP256R1_P)
+        y = pack(ids.point.y, SECP256R1_P)
+
+        value = new_x = (pow(slope, 2, SECP256R1_P) - 2 * x) % SECP256R1_P
+    %}
+    let (new_x: BigInt3) = nondet_bigint3();
+    return new_x;
+}

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 ();
+}

requirements.txt

@@ -3,4 +3,4 @@ bitarray==2.7.3
 fastecdsa==2.3.2
 sympy==1.11.1
 typeguard==2.13.3
-cairo-lang==0.13.3
+cairo-lang==0.13.5

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()?;