Add optional prover parameters file path to the adapted Stwo CLI

stwo_cairo_prover/Cargo.toml

@@ -36,9 +36,11 @@ serde_json = "1.0.1"
 stwo_cairo_prover = { path = "crates/prover", version = "~0.1.0" }
 stwo_cairo_utils = { path = "crates/utils", version = "~0.1.0" }
 # TODO(ShaharS): take stwo version from the source repository.
-stwo-prover = { git = "https://github.com/starkware-libs/stwo", rev = "438c107", features = [
+stwo-prover = { git = "https://github.com/starkware-libs/stwo", rev = "0445252", features = [
     "parallel",
 ], default-features = false }
+stwo-air-utils-derive = { git = "https://github.com/starkware-libs/stwo", rev = "0445252" }
+stwo-air-utils = { git = "https://github.com/starkware-libs/stwo", rev = "0445252" }
 thiserror = { version = "2.0.10", default-features = false }
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"

stwo_cairo_prover/crates/adapted_prover/Cargo.toml

@@ -15,3 +15,4 @@ stwo_cairo_utils.workspace = true
 stwo-prover.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
+serde.workspace = true

stwo_cairo_prover/crates/adapted_prover/src/main.rs

@@ -2,14 +2,22 @@ use std::path::PathBuf;
 use std::process::ExitCode;
 
 use clap::Parser;
+use serde::Serialize;
 use stwo_cairo_prover::cairo_air::{
-    prove_cairo, verify_cairo, CairoVerificationError, ConfigBuilder,
+    prove_cairo, verify_cairo, CairoVerificationError, ChannelHash, ConfigBuilder, ProverConfig,
+    ProverParameters,
 };
 use stwo_cairo_prover::input::vm_import::{adapt_vm_output, VmImportError};
 use stwo_cairo_prover::input::ProverInput;
 use stwo_cairo_utils::binary_utils::run_binary;
+use stwo_prover::core::backend::simd::SimdBackend;
+use stwo_prover::core::backend::BackendForChannel;
+use stwo_prover::core::channel::MerkleChannel;
+use stwo_prover::core::fri::FriConfig;
+use stwo_prover::core::pcs::PcsConfig;
 use stwo_prover::core::prover::ProvingError;
 use stwo_prover::core::vcs::blake2_merkle::Blake2sMerkleChannel;
+use stwo_prover::core::vcs::poseidon252_merkle::Poseidon252MerkleChannel;
 use thiserror::Error;
 use tracing::{span, Level};
 
@@ -35,6 +43,9 @@ struct Args {
     pub_json: PathBuf,
     #[structopt(long = "priv_json")]
     priv_json: PathBuf,
+    /// The path to the JSON file containing the prover parameters (optional).
+    #[structopt(long = "params_json")]
+    params_json: Option<PathBuf>,
     /// The output file path for the proof.
     #[structopt(long = "proof_path")]
     proof_path: PathBuf,
@@ -67,6 +78,30 @@ fn main() -> ExitCode {
     run_binary(run, "adapted_stwo")
 }
 
+/// Generates proof given the Cairo VM output and prover config/parameters.  
+/// Serializes the proof as JSON and write to the output path.
+/// Verifies the proof in case the respective flag is set.
+fn run_inner<MC: MerkleChannel>(
+    vm_output: ProverInput,
+    prover_config: ProverConfig,
+    pcs_config: PcsConfig,
+    verify: bool,
+    proof_path: PathBuf,
+) -> Result<(), Error>
+where
+    SimdBackend: BackendForChannel<MC>,
+    MC::H: Serialize,
+{
+    let proof = prove_cairo::<MC>(vm_output, prover_config, pcs_config)?;
+    std::fs::write(&proof_path, serde_json::to_string(&proof)?)?;
+
+    if verify {
+        verify_cairo::<MC>(proof, pcs_config)?;
+        log::info!("Proof verified successfully");
+    }
+    Ok(())
+}
+
 fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
     let _span = span!(Level::INFO, "run").entered();
     let args = Args::try_parse_from(args)?;
@@ -83,15 +118,37 @@ fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
         vm_output.state_transitions.casm_states_by_opcode
     );
 
-    // TODO(Ohad): Propagate hash from CLI args.
-    let proof = prove_cairo::<Blake2sMerkleChannel>(vm_output, prover_config)?;
-
-    std::fs::write(args.proof_path, serde_json::to_string(&proof)?)?;
+    let params: ProverParameters = match args.params_json {
+        Some(path) => serde_json::from_str(&std::fs::read_to_string(path)?)?,
+        None => default_parameters(),
+    };
 
-    if args.verify {
-        verify_cairo::<Blake2sMerkleChannel>(proof)?;
-        log::info!("Proof verified successfully");
-    }
+    let run_inner_fn = match params.channel_hash {
+        ChannelHash::Blake2s => run_inner::<Blake2sMerkleChannel>,
+        ChannelHash::Poseidon252 => run_inner::<Poseidon252MerkleChannel>,
+    };
 
+    run_inner_fn(
+        vm_output,
+        prover_config,
+        params.pcs_config,
+        args.verify,
+        args.proof_path,
+    )?;
     Ok(())
 }
+
+/// The default prover paramters (96 bits of security).
+pub fn default_parameters() -> ProverParameters {
+    ProverParameters {
+        channel_hash: ChannelHash::Blake2s,
+        pcs_config: PcsConfig {
+            pow_bits: 26,
+            fri_config: FriConfig {
+                log_last_layer_degree_bound: 7,
+                log_blowup_factor: 1,
+                n_queries: 70,
+            },
+        },
+    }
+}

stwo_cairo_prover/crates/cairo-serialize/src/lib.rs

@@ -4,7 +4,7 @@ pub use stwo_cairo_serialize_derive::CairoSerialize;
 use stwo_prover::core::fields::m31::BaseField;
 use stwo_prover::core::fields::qm31::SecureField;
 use stwo_prover::core::fri::{FriLayerProof, FriProof};
-use stwo_prover::core::pcs::CommitmentSchemeProof;
+use stwo_prover::core::pcs::{CommitmentSchemeProof, PcsConfig};
 use stwo_prover::core::poly::line::LinePoly;
 use stwo_prover::core::prover::StarkProof;
 use stwo_prover::core::vcs::ops::MerkleHasher;
@@ -116,13 +116,15 @@ where
             queried_values,
             proof_of_work,
             fri_proof,
+            config,
         } = self;
         commitments.serialize(output);
         sampled_values.serialize(output);
         decommitments.serialize(output);
         queried_values.serialize(output);
         output.push((*proof_of_work).into());
         fri_proof.serialize(output);
+        config.serialize(output);
     }
 }
 
@@ -183,3 +185,12 @@ impl<T0: CairoSerialize, T1: CairoSerialize, T2: CairoSerialize> CairoSerialize
         v2.serialize(output);
     }
 }
+
+impl CairoSerialize for PcsConfig {
+    fn serialize(&self, output: &mut Vec<FieldElement>) {
+        output.push((self.pow_bits).into());
+        output.push((self.fri_config.log_blowup_factor).into());
+        output.push((self.fri_config.log_last_layer_degree_bound).into());
+        output.push((self.fri_config.n_queries).into());
+    }
+}

stwo_cairo_prover/crates/prover/Cargo.toml

@@ -9,8 +9,8 @@ std = ["dep:sonic-rs"]
 
 [dependencies]
 air_structs_derive = { path = "../air_structs_derive" }
-stwo-air-utils-derive = { git = "https://github.com/starkware-libs/stwo", rev = "438c107" }
-stwo-air-utils = { git = "https://github.com/starkware-libs/stwo", rev = "438c107" }
+stwo-air-utils-derive.workspace = true
+stwo-air-utils.workspace = true
 bytemuck.workspace = true
 cairo-lang-casm.workspace = true
 cairo-vm.workspace = true