Consistently pass through random_tape

jolt-core/src/benches/bench.rs

@@ -18,7 +18,7 @@ use crate::jolt::vm::instruction_lookups::InstructionLookupsProof;
 use crate::jolt::vm::rv32i_vm::{RV32IJoltVM, RV32I};
 use crate::jolt::vm::Jolt;
 use crate::lasso::surge::Surge;
-use crate::utils::math::Math;
+use crate::utils::{math::Math, random::RandomTape};
 use crate::{jolt::instruction::xor::XORInstruction, utils::gen_random_point};
 use ark_curve25519::{EdwardsProjective, Fr};
 use ark_std::{log2, test_rng};
@@ -145,8 +145,9 @@ fn rv32i_lookup_benchmarks() -> Vec<(tracing::Span, Box<dyn FnOnce()>)> {
 
     let r: Vec<Fr> = gen_random_point::<Fr>(ops.len().log_2());
     let mut prover_transcript = Transcript::new(b"example");
+    let mut random_tape = RandomTape::new(b"test_tape");
     let proof: InstructionLookupsProof<Fr, EdwardsProjective> =
-      RV32IJoltVM::prove_instruction_lookups(ops, r.clone(), &mut prover_transcript);
+      RV32IJoltVM::prove_instruction_lookups(ops, r.clone(), &mut prover_transcript, &mut random_tape);
     let mut verifier_transcript = Transcript::new(b"example");
     assert!(RV32IJoltVM::verify_instruction_lookups(proof, r, &mut verifier_transcript).is_ok());
   });

jolt-core/src/jolt/vm/instruction_lookups.rs

@@ -17,7 +17,7 @@ use crate::{
     dense_mlpoly::{DensePolynomial, PolyCommitmentGens},
     eq_poly::EqPolynomial,
     identity_poly::IdentityPolynomial,
-    structured_poly::{StructuredOpeningProof, BatchablePolynomials},
+    structured_poly::{BatchablePolynomials, StructuredOpeningProof},
     unipoly::{CompressedUniPoly, UniPoly},
   },
   subprotocols::{
@@ -751,6 +751,7 @@ where
     &self,
     r: Vec<F>,
     transcript: &mut Transcript,
+    random_tape: &mut RandomTape<G>,
   ) -> InstructionLookupsProof<F, G> {
     <Transcript as ProofTranscript<G>>::append_protocol_name(transcript, Self::protocol_name());
     let polynomials = self.polynomialize();
@@ -785,16 +786,14 @@ where
         transcript,
       );
 
-    let mut random_tape = RandomTape::new(b"proof");
-
     // Create a single opening proof for the flag_evals and memory_evals
     let sumcheck_openings = PrimarySumcheckOpenings::prove_openings(
       &batched_polys,
       &commitment,
       &r_primary_sumcheck,
       (E_evals, flag_evals),
       transcript,
-      &mut random_tape,
+      random_tape,
     );
 
     let primary_sumcheck = PrimarySumcheck {
@@ -809,7 +808,7 @@ where
       &batched_polys,
       &commitment,
       transcript,
-      &mut random_tape,
+      random_tape,
     );
 
     InstructionLookupsProof {

jolt-core/src/jolt/vm/mod.rs

@@ -51,10 +51,11 @@ pub trait Jolt<F: PrimeField, G: CurveGroup<ScalarField = F>, const C: usize, co
     ops: Vec<Self::InstructionSet>,
     r: Vec<F>,
     transcript: &mut Transcript,
+    random_tape: &mut RandomTape<G>,
   ) -> InstructionLookupsProof<F, G> {
     let instruction_lookups =
       InstructionLookups::<F, G, Self::InstructionSet, Self::Subtables, C, M>::new(ops);
-    instruction_lookups.prove_lookups(r, transcript)
+    instruction_lookups.prove_lookups(r, transcript, random_tape)
   }
 
   fn verify_instruction_lookups(
@@ -91,6 +92,7 @@ pub trait Jolt<F: PrimeField, G: CurveGroup<ScalarField = F>, const C: usize, co
     memory_trace: Vec<MemoryOp>,
     memory_size: usize,
     transcript: &mut Transcript,
+    random_tape: &mut RandomTape<G>,
   ) -> (
     MemoryCheckingProof<
       G,
@@ -110,13 +112,12 @@ pub trait Jolt<F: PrimeField, G: CurveGroup<ScalarField = F>, const C: usize, co
     let batched_polys = memory.batch();
     let commitments: MemoryCommitment<G> = ReadWriteMemory::commit(&batched_polys);
 
-    let mut random_tape = RandomTape::new(b"proof");
     let memory_checking_proof = memory.prove_memory_checking(
       &memory,
       &batched_polys,
       &commitments,
       transcript,
-      &mut random_tape,
+      random_tape,
     );
 
     let timestamp_validity_lookups: Vec<SLTUInstruction> = read_timestamps