openvm_recursion_circuit/system/
dummy.rs

1// Utilities for dummy tracegen
2use openvm_stark_backend::{keygen::types::MultiStarkVerifyingKey, proof::Proof};
3use openvm_stark_sdk::config::baby_bear_poseidon2::{BabyBearPoseidon2Config, EF, F};
4use p3_field::{BasedVectorSpace, PrimeCharacteristicRing};
5
6use crate::{
7    bus::{CommitmentsBusMessage, ConstraintSumcheckRandomness, WhirModuleMessage},
8    system::Preflight,
9};
10
11impl Preflight {
12    pub(crate) fn batch_constraint_sumcheck_randomness(
13        &self,
14    ) -> Vec<ConstraintSumcheckRandomness<F>> {
15        self.batch_constraint
16            .sumcheck_rnd
17            .iter()
18            .enumerate()
19            .map(|(i, r)| ConstraintSumcheckRandomness {
20                idx: F::from_usize(i),
21                challenge: r.as_basis_coefficients_slice().try_into().unwrap(),
22            })
23            .collect()
24    }
25
26    pub fn whir_module_msg(&self, proof: &Proof<BabyBearPoseidon2Config>) -> WhirModuleMessage<F> {
27        let mu = self.stacking.stacking_batching_challenge;
28        let mut mu_pows = mu.powers();
29        let mut claim = EF::ZERO;
30        for openings in &proof.stacking_proof.stacking_openings {
31            for &opening in openings {
32                claim += mu_pows.next().unwrap() * opening;
33            }
34        }
35        WhirModuleMessage {
36            tidx: F::from_usize(self.stacking.post_tidx),
37            claim: claim.as_basis_coefficients_slice().try_into().unwrap(),
38        }
39    }
40
41    pub fn whir_commitments_msgs(
42        &self,
43        proof: &Proof<BabyBearPoseidon2Config>,
44    ) -> Vec<CommitmentsBusMessage<F>> {
45        let mut messages = vec![];
46        for (i, commit) in proof.whir_proof.codeword_commits.iter().enumerate() {
47            messages.push(CommitmentsBusMessage {
48                major_idx: F::from_usize(i + 1),
49                minor_idx: F::ZERO,
50                commitment: *commit,
51            });
52        }
53        messages
54    }
55
56    pub fn stacking_commitments_msgs(
57        &self,
58        vk: &MultiStarkVerifyingKey<BabyBearPoseidon2Config>,
59        proof: &Proof<BabyBearPoseidon2Config>,
60    ) -> Vec<CommitmentsBusMessage<F>> {
61        let mut messages = vec![];
62        messages.push(CommitmentsBusMessage {
63            major_idx: F::ZERO,
64            minor_idx: F::ZERO,
65            commitment: proof.common_main_commit,
66        });
67        let mut commit_idx = F::ONE;
68        for (air_id, vdata) in &self.proof_shape.sorted_trace_vdata {
69            let vk = &vk.inner.per_air[*air_id];
70            let commits = vk
71                .preprocessed_data
72                .as_ref()
73                .into_iter()
74                .map(|p| p.commit)
75                .chain(vdata.cached_commitments.iter().cloned());
76
77            for commit in commits {
78                messages.push(CommitmentsBusMessage {
79                    major_idx: F::ZERO,
80                    minor_idx: commit_idx,
81                    commitment: commit,
82                });
83                commit_idx += F::ONE;
84            }
85        }
86        messages
87    }
88}