openvm_native_recursion/fri/
witness.rs

1use openvm_native_compiler::{
2    ir::{Builder, Witness, WitnessRef},
3    prelude::*,
4};
5
6use super::types::BatchOpeningVariable;
7use crate::{
8    config::outer::{
9        OuterBatchOpening, OuterCommitPhaseStep, OuterConfig, OuterDigest, OuterFriProof,
10        OuterQueryProof,
11    },
12    fri::types::{FriCommitPhaseProofStepVariable, FriProofVariable, FriQueryProofVariable},
13    vars::HintSlice,
14    witness::{VectorWitnessable, Witnessable},
15};
16
17type C = OuterConfig;
18
19impl Witnessable<C> for OuterCommitPhaseStep {
20    type WitnessVariable = FriCommitPhaseProofStepVariable<C>;
21
22    fn read(&self, builder: &mut Builder<C>) -> Self::WitnessVariable {
23        let sibling_value = self.sibling_value.read(builder);
24        let opening_proof = read_opening_proof(builder, &self.opening_proof);
25        Self::WitnessVariable {
26            sibling_value,
27            opening_proof,
28        }
29    }
30
31    fn write(&self, witness: &mut Witness<OuterConfig>) {
32        self.sibling_value.write(witness);
33        write_opening_proof(witness, &self.opening_proof);
34    }
35}
36
37impl VectorWitnessable<C> for OuterCommitPhaseStep {}
38
39impl Witnessable<C> for OuterQueryProof {
40    type WitnessVariable = FriQueryProofVariable<C>;
41
42    fn read(&self, builder: &mut Builder<C>) -> Self::WitnessVariable {
43        let input_proof = self.input_proof.read(builder);
44        let commit_phase_openings = self.commit_phase_openings.read(builder);
45        Self::WitnessVariable {
46            input_proof,
47            commit_phase_openings,
48        }
49    }
50
51    fn write(&self, witness: &mut Witness<OuterConfig>) {
52        self.input_proof.write(witness);
53        self.commit_phase_openings.write(witness);
54    }
55}
56
57impl VectorWitnessable<C> for OuterQueryProof {}
58
59impl Witnessable<C> for OuterFriProof {
60    type WitnessVariable = FriProofVariable<C>;
61
62    fn read(&self, builder: &mut Builder<C>) -> Self::WitnessVariable {
63        let commit_phase_commits = self.commit_phase_commits.read(builder);
64        let commit_pow_witnesses = self.commit_pow_witnesses.read(builder);
65        let query_proofs = self.query_proofs.read(builder);
66        let final_poly = self.final_poly.read(builder);
67        let query_pow_witness = self.query_pow_witness.read(builder);
68        Self::WitnessVariable {
69            commit_phase_commits,
70            commit_pow_witnesses,
71            query_proofs,
72            final_poly,
73            query_pow_witness,
74        }
75    }
76
77    fn write(&self, witness: &mut Witness<OuterConfig>) {
78        self.commit_phase_commits.write(witness);
79        self.commit_pow_witnesses.write(witness);
80        <Vec<_> as Witnessable<C>>::write(&self.query_proofs, witness);
81        self.final_poly.write(witness);
82        self.query_pow_witness.write(witness);
83    }
84}
85
86impl Witnessable<C> for OuterBatchOpening {
87    type WitnessVariable = BatchOpeningVariable<C>;
88
89    fn read(&self, builder: &mut Builder<C>) -> Self::WitnessVariable {
90        let opened_values_refs: Vec<WitnessRef> = self
91            .opened_values
92            .iter()
93            .flatten()
94            .map(|x| x.read(builder).into())
95            .collect();
96        let length = Usize::from(opened_values_refs.len());
97        let id = builder.witness_load(opened_values_refs);
98        let opened_values = HintSlice { length, id };
99
100        let opening_proof = read_opening_proof(builder, &self.opening_proof);
101        Self::WitnessVariable {
102            opened_values,
103            opening_proof,
104        }
105    }
106
107    fn write(&self, witness: &mut Witness<OuterConfig>) {
108        let opened_values: Vec<_> = self
109            .opened_values
110            .iter()
111            .flat_map(|op| op.to_vec())
112            .collect();
113        opened_values.write(witness);
114        write_opening_proof(witness, &self.opening_proof);
115    }
116}
117
118impl VectorWitnessable<C> for OuterBatchOpening {}
119impl VectorWitnessable<C> for Vec<OuterBatchOpening> {}
120
121fn read_opening_proof(builder: &mut Builder<C>, opening_proof: &[OuterDigest]) -> HintSlice<C> {
122    let opening_proof: Vec<WitnessRef> = opening_proof
123        .iter()
124        .flatten()
125        .map(|x| x.read(builder).into())
126        .collect();
127    let length = Usize::from(opening_proof.len());
128    let id = builder.witness_load(opening_proof);
129    HintSlice { length, id }
130}
131fn write_opening_proof(witness: &mut Witness<OuterConfig>, opening_proof: &[OuterDigest]) {
132    let opening_proof: Vec<_> = opening_proof.iter().flat_map(|op| op.to_vec()).collect();
133    opening_proof.write(witness);
134}
openvm_native_recursion/fri/witness.rs

openvm_native_recursion/fri/
witness.rs
