refactor the STARK's interface: no more state in the struct

triton-vm/benches/prove_fib_100.rs

@@ -16,6 +16,7 @@ use triton_vm::shared_tests::FIBONACCI_SEQUENCE;
 use triton_vm::stark::Stark;
 use triton_vm::table::master_table::MasterBaseTable;
 use triton_vm::vm::simulate;
+use triton_vm::StarkParameters;
 
 /// cargo criterion --bench prove_fib_100
 fn prove_fib_100(criterion: &mut Criterion) {
@@ -51,21 +52,25 @@ fn prove_fib_100(criterion: &mut Criterion) {
         output,
         padded_height,
     };
-    let stark = Stark::new(claim, Default::default());
-    let _proof = stark.prove(aet.clone(), &mut maybe_profiler);
+    let parameters = StarkParameters::default();
+    let _proof = Stark::prove(&parameters, &claim, &aet, &mut maybe_profiler);
+
+    let max_degree =
+        Stark::derive_max_degree(claim.padded_height, parameters.num_trace_randomizers);
+    let fri = Stark::derive_fri(&parameters, max_degree);
 
     if let Some(profiler) = maybe_profiler.as_mut() {
         profiler.finish();
         report = profiler.report(
             Some(aet.processor_trace.nrows()),
-            Some(stark.claim.padded_height),
-            Some(stark.fri.domain.length),
+            Some(claim.padded_height),
+            Some(fri.domain.length),
         );
     }
     //start the benchmarking
     group.bench_function(fib_100, |bencher| {
         bencher.iter(|| {
-            let _proof = stark.prove(aet.clone(), &mut None);
+            let _proof = Stark::prove(&parameters, &claim, &aet, &mut None);
         });
     });
 

triton-vm/benches/prove_halt.rs

@@ -47,15 +47,18 @@ fn prove_halt(_criterion: &mut Criterion) {
         padded_height,
     };
     let parameters = StarkParameters::default();
-    let stark = Stark::new(claim, parameters);
-    let proof = stark.prove(aet, &mut maybe_profiler);
+    let proof = Stark::prove(&parameters, &claim, &aet, &mut maybe_profiler);
+
+    let max_degree =
+        Stark::derive_max_degree(claim.padded_height, parameters.num_trace_randomizers);
+    let fri = Stark::derive_fri(&parameters, max_degree);
 
     if let Some(profiler) = &mut maybe_profiler {
         profiler.finish();
         report = profiler.report(
             Some(cycle_count),
-            Some(stark.claim.padded_height),
-            Some(stark.fri.domain.length),
+            Some(claim.padded_height),
+            Some(fri.domain.length),
         );
     };
 

triton-vm/benches/verify_halt.rs

@@ -31,10 +31,11 @@ fn verify_halt(criterion: &mut Criterion) {
     };
 
     let program_digest = Tip5::hash(&program);
-    let stark_parameters = StarkParameters::default();
+    let parameters = StarkParameters::default();
     let filename = "halt.tsp";
     let mut maybe_cycle_count = None;
-    let (proof, stark) = if proof_file_exists(filename) {
+
+    let (claim, proof) = if proof_file_exists(filename) {
         let proof = match load_proof(filename) {
             Ok(p) => p,
             Err(e) => panic!("Could not load proof from disk: {e:?}"),
@@ -46,8 +47,7 @@ fn verify_halt(criterion: &mut Criterion) {
             output: vec![],
             padded_height,
         };
-        let stark = Stark::new(claim, stark_parameters);
-        (proof, stark)
+        (claim, proof)
     } else {
         let (aet, output, err) = simulate(&program, vec![], vec![]);
         if let Some(error) = err {
@@ -62,31 +62,34 @@ fn verify_halt(criterion: &mut Criterion) {
             output,
             padded_height,
         };
-        let stark = Stark::new(claim, stark_parameters);
-        let proof = stark.prove(aet, &mut None);
+        let proof = Stark::prove(&parameters, &claim, &aet, &mut None);
         if let Err(e) = save_proof(filename, proof.clone()) {
             panic!("Problem! could not save proof to disk: {e:?}");
         }
-        (proof, stark)
+        (claim, proof)
     };
 
-    let result = stark.verify(proof.clone(), &mut None);
+    let result = Stark::verify(&parameters, &claim, &proof, &mut None);
     if let Err(e) = result {
         panic!("The Verifier is unhappy! {e}");
     }
 
+    let max_degree =
+        Stark::derive_max_degree(claim.padded_height, parameters.num_trace_randomizers);
+    let fri = Stark::derive_fri(&parameters, max_degree);
+
     let mut maybe_profiler = Some(TritonProfiler::new("Verify Halt"));
     let mut report: Report = Report::placeholder();
 
     group.bench_function(halt, |bencher| {
         bencher.iter(|| {
-            let _result = stark.verify(proof.clone(), &mut maybe_profiler);
+            let _result = Stark::verify(&parameters, &claim, &proof, &mut maybe_profiler);
             if let Some(profiler) = maybe_profiler.as_mut() {
                 profiler.finish();
                 report = profiler.report(
                     maybe_cycle_count,
-                    Some(stark.claim.padded_height),
-                    Some(stark.fri.domain.length),
+                    Some(claim.padded_height),
+                    Some(fri.domain.length),
                 );
             }
             maybe_profiler = None;

triton-vm/src/lib.rs

@@ -11,7 +11,7 @@ use twenty_first::util_types::algebraic_hasher::AlgebraicHasher;
 pub use crate::proof::Claim;
 use crate::proof::Proof;
 use crate::stark::Stark;
-use crate::stark::StarkParameters;
+pub use crate::stark::StarkParameters;
 use crate::table::master_table::MasterBaseTable;
 
 pub mod arithmetic_domain;
@@ -41,7 +41,11 @@ pub mod vm;
 /// `assert` instruction, proof generation will fail.
 ///
 /// The default STARK parameters used by Triton VM give a (conjectured) security level of 160 bits.
-pub fn prove(source_code: &str, public_input: &[u64], secret_input: &[u64]) -> (Claim, Proof) {
+pub fn prove(
+    source_code: &str,
+    public_input: &[u64],
+    secret_input: &[u64],
+) -> (StarkParameters, Claim, Proof) {
     let canonical_representation_error =
         "input must contain only elements in canonical representation, i.e., \
         elements smaller than the prime field's modulus 2^64 - 2^32 + 1.";
@@ -96,18 +100,16 @@ pub fn prove(source_code: &str, public_input: &[u64], secret_input: &[u64]) -> (
         padded_height: MasterBaseTable::padded_height(&aet),
     };
 
-    // Construct a new STARK instance. The default parameters give a (conjectured) security level
-    // of 160 bits.
-    let stark = Stark::new(claim.clone(), StarkParameters::default());
+    // The default parameters give a (conjectured) security level of 160 bits.
+    let parameters = StarkParameters::default();
 
     // Generate the proof.
-    let proof = stark.prove(aet, &mut None);
+    let proof = Stark::prove(&parameters, &claim, &aet, &mut None);
 
-    (claim, proof)
+    (parameters, claim, proof)
 }
 
 /// Verify a proof generated by [`prove`].
-pub fn verify(claim: Claim, proof: Proof) -> bool {
-    let stark = Stark::new(claim, StarkParameters::default());
-    stark.verify(proof, &mut None).unwrap_or(false)
+pub fn verify(parameters: &StarkParameters, claim: &Claim, proof: &Proof) -> bool {
+    Stark::verify(parameters, claim, proof, &mut None).unwrap_or(false)
 }

triton-vm/src/shared_tests.rs

@@ -54,7 +54,7 @@ pub fn parse_simulate_prove(
     input_symbols: Vec<u64>,
     secret_input_symbols: Vec<u64>,
     maybe_profiler: &mut Option<TritonProfiler>,
-) -> (Stark, Proof) {
+) -> (StarkParameters, Claim, Proof) {
     let (aet, output_symbols) = parse_setup_simulate(
         code,
         input_symbols.clone(),
@@ -72,13 +72,12 @@ pub fn parse_simulate_prove(
     let log_expansion_factor = 2;
     let security_level = 32;
     let parameters = StarkParameters::new(security_level, log_expansion_factor);
-    let stark = Stark::new(claim, parameters);
 
     prof_start!(maybe_profiler, "prove");
-    let proof = stark.prove(aet, maybe_profiler);
+    let proof = Stark::prove(&parameters, &claim, &aet, maybe_profiler);
     prof_stop!(maybe_profiler, "prove");
 
-    (stark, proof)
+    (parameters, claim, proof)
 }
 
 /// Source code and associated input. Primarily for testing of the VM's instructions.