Add recursive precompile verifier coverage

Author: huitseeker

crates/lib/core/tests/sys/mod.rs

@@ -191,15 +191,15 @@ fn log_precompile_request_procedure() {
     );
 
     let program_info = ProgramInfo::from(program);
-    let (_, transcript_digest) = miden_verifier::verify_with_precompiles(
+    let (_, pc_transcript_digest) = miden_verifier::verify_with_precompiles(
         program_info,
         stack_inputs,
         stack_outputs,
         proof,
         &verifier_registry,
     )
     .expect("proof verification with precompiles failed");
-    assert_eq!(transcript.finalize(), transcript_digest);
+    assert_eq!(transcript.finalize(), pc_transcript_digest);
 }
 
 #[derive(Clone)]

miden-vm/tests/integration/prove_verify.rs

@@ -471,7 +471,7 @@ mod fast_parallel {
     };
     use miden_core_lib::CoreLibrary;
     use miden_processor::{
-        DefaultHost, ExecutionOptions, FastProcessor, ProcessorState, StackInputs,
+        DefaultHost, ExecutionOptions, FastProcessor, ProcessorState, StackInputs, StackOutputs,
         advice::{AdviceInputs, AdviceMutation},
         event::{EventError, EventHandler},
         trace::build_trace,
@@ -592,6 +592,56 @@ mod fast_parallel {
 
     #[test]
     fn test_prove_from_trace_sync_preserves_precompile_requests() {
+        let LoggedPrecompileProofFixture {
+            program,
+            stack_inputs,
+            stack_outputs,
+            proof,
+            verifier_registry,
+            expected_transcript,
+        } = prove_logged_precompile_fixture(HashFunction::Blake3_256);
+
+        let (_, pc_transcript_digest) = verify_with_precompiles(
+            program.into(),
+            stack_inputs,
+            stack_outputs,
+            proof,
+            &verifier_registry,
+        )
+        .expect("proof verification with precompiles failed");
+        assert_eq!(expected_transcript.finalize(), pc_transcript_digest);
+    }
+
+    #[test]
+    fn test_poseidon2_recursive_verify_with_precompile_requests() {
+        let LoggedPrecompileProofFixture {
+            program,
+            stack_inputs,
+            stack_outputs,
+            proof,
+            verifier_registry,
+            expected_transcript,
+        } = prove_logged_precompile_fixture(HashFunction::Poseidon2);
+
+        super::assert_recursive_verify(
+            program.to_info(),
+            stack_inputs,
+            stack_outputs,
+            expected_transcript.state(),
+            &proof,
+        );
+
+        verify_with_precompiles(
+            program.into(),
+            stack_inputs,
+            stack_outputs,
+            proof,
+            &verifier_registry,
+        )
+        .expect("proof verification with precompiles failed");
+    }
+
+    fn prove_logged_precompile_fixture(hash_fn: HashFunction) -> LoggedPrecompileProofFixture {
         const NUM_ITERATIONS: usize = 256;
         let fixtures = logged_precompile_fixtures(NUM_ITERATIONS);
 
@@ -638,7 +688,7 @@ mod fast_parallel {
 
         let (stack_outputs, proof) = prove_from_trace_sync(TraceProvingInputs::new(
             trace_inputs,
-            ProvingOptions::with_96_bit_security(HashFunction::Blake3_256),
+            ProvingOptions::with_96_bit_security(hash_fn),
         ))
         .expect("prove_from_trace_sync failed");
 
@@ -663,15 +713,23 @@ mod fast_parallel {
         }
         assert_eq!(transcript.finalize(), expected_transcript.finalize());
 
-        let (_, transcript_digest) = verify_with_precompiles(
-            program.into(),
+        LoggedPrecompileProofFixture {
+            program,
             stack_inputs,
             stack_outputs,
             proof,
-            &verifier_registry,
-        )
-        .expect("proof verification with precompiles failed");
-        assert_eq!(expected_transcript.finalize(), transcript_digest);
+            verifier_registry,
+            expected_transcript,
+        }
+    }
+
+    struct LoggedPrecompileProofFixture {
+        program: Program,
+        stack_inputs: StackInputs,
+        stack_outputs: StackOutputs,
+        proof: ExecutionProof,
+        verifier_registry: PrecompileVerifierRegistry,
+        expected_transcript: PrecompileTranscript,
     }
 
     fn logged_precompile_fixtures(num_iterations: usize) -> Vec<LoggedPrecompileFixture> {

processor/src/fast/mod.rs

@@ -144,7 +144,7 @@ impl FastProcessor {
             stack,
             advice: self.advice,
             memory: self.memory,
-            final_pc_transcript: self.pc_transcript,
+            final_precompile_transcript: self.pc_transcript,
         }
     }
 
@@ -634,7 +634,7 @@ pub struct ExecutionOutput {
     pub stack: StackOutputs,
     pub advice: AdviceProvider,
     pub memory: Memory,
-    pub final_pc_transcript: PrecompileTranscript,
+    pub final_precompile_transcript: PrecompileTranscript,
 }
 
 // EXECUTION CONTEXT INFO

processor/src/trace/mod.rs

@@ -65,7 +65,7 @@ impl TraceBuildOutput {
             stack,
             mut advice,
             memory: _,
-            final_pc_transcript,
+            final_precompile_transcript,
         } = execution_output;
 
         Self {