openvm_continuations/prover/inner/
trace.rs

1use itertools::Itertools;
2use openvm_recursion_circuit::system::{
3    AggregationSubCircuit, CachedTraceCtx, VerifierExternalData, VerifierTraceGen,
4};
5use openvm_stark_backend::{
6    proof::Proof,
7    prover::{ProverBackend, ProvingContext},
8};
9use openvm_stark_sdk::config::baby_bear_poseidon2::{
10    default_duplex_sponge_recorder, Digest, EF, F,
11};
12use openvm_verify_stark_host::pvs::{DeferralPvs, VkCommit};
13use tracing::instrument;
14
15use super::{ChildVkKind, InnerAggregationProver};
16use crate::{
17    circuit::inner::{InnerTraceGen, ProofsType},
18    SC,
19};
20
21impl<PB, S, T> InnerAggregationProver<PB, S, T>
22where
23    PB: ProverBackend<Val = F, Challenge = EF, Commitment = Digest>,
24    S: AggregationSubCircuit,
25    PB::Matrix: Clone,
26{
27    #[instrument(name = "trace_gen", skip_all)]
28    pub fn generate_proving_ctx<DC>(
29        &self,
30        proofs: &[Proof<SC>],
31        child_vk_kind: ChildVkKind,
32        proofs_type: ProofsType,
33        absent_trace_pvs: Option<(DeferralPvs<F>, bool)>,
34        device_ctx: &DC,
35    ) -> ProvingContext<PB>
36    where
37        S: VerifierTraceGen<PB, SC, DC>,
38        T: InnerTraceGen<PB, DC>,
39        DC: Clone + Send + Sync,
40    {
41        assert!(proofs.len() <= self.circuit.verifier_circuit.max_num_proofs());
42
43        let (child_vk, child_vk_pcs_data) = match child_vk_kind {
44            ChildVkKind::RecursiveSelf => (&self.vk, self.self_vk_pcs_data.clone().unwrap()),
45            _ => (&self.child_vk, self.child_vk_pcs_data.clone()),
46        };
47        let child_is_app = matches!(child_vk_kind, ChildVkKind::App);
48        let child_vk_commit = VkCommit {
49            cached_commit: child_vk_pcs_data.commitment,
50            vk_pre_hash: child_vk.pre_hash,
51        };
52
53        let pre_data = self
54            .agg_node_tracegen
55            .generate_pre_verifier_subcircuit_ctxs(
56                proofs,
57                proofs_type,
58                absent_trace_pvs,
59                child_is_app,
60                child_vk_commit,
61                device_ctx,
62            );
63
64        let power_check_inputs = vec![];
65        let mut external_data = VerifierExternalData {
66            poseidon2_compress_inputs: &pre_data.poseidon2_compress_inputs,
67            poseidon2_permute_inputs: &pre_data.poseidon2_permute_inputs,
68            range_check_inputs: &pre_data.range_check_inputs,
69            power_check_inputs: &power_check_inputs,
70            required_heights: None,
71            final_transcript_state: None,
72        };
73
74        let subcircuit_ctxs = self
75            .circuit
76            .verifier_circuit
77            .generate_proving_ctxs(
78                child_vk,
79                CachedTraceCtx::PcsData(child_vk_pcs_data),
80                proofs,
81                &mut external_data,
82                device_ctx,
83                default_duplex_sponge_recorder(),
84            )
85            .unwrap();
86        let post_ctxs = self
87            .agg_node_tracegen
88            .generate_post_verifier_subcircuit_ctxs(proofs, proofs_type, child_is_app, device_ctx);
89
90        ProvingContext {
91            per_trace: pre_data
92                .air_proving_ctxs
93                .into_iter()
94                .chain(subcircuit_ctxs)
95                .chain(post_ctxs)
96                .enumerate()
97                .collect_vec(),
98        }
99    }
100}