swiftness/
transform.rs

1use swiftness_air::{
2    dynamic::DynamicParams,
3    public_memory::PublicInput as PublicInputVerifier,
4    trace::{
5        config::Config as TraceConfigVerifier, Decommitment as TraceDecommitmentVerifier,
6        UnsentCommitment as TraceUnsentCommitmentVerifier, Witness as TraceWitnessVerifier,
7    },
8    types::{AddrValue, Page, SegmentInfo as SegmentInfoVerifier},
9};
10use swiftness_commitment::{
11    table::{
12        config::Config as TableConfigVerifier,
13        types::{
14            Decommitment as TableDecommitmentVerifier, Witness as TableCommitmentWitnessVerifier,
15        },
16    },
17    vector::{
18        config::Config as VectorConfigVerifier, types::Witness as VectorCommitmentWitnessVerifier,
19    },
20};
21use swiftness_fri::{
22    config::Config as FriConfigVerifier,
23    types::{
24        LayerWitness, UnsentCommitment as FriUnsentCommitmentVerifier,
25        Witness as FriWitnessVerifier,
26    },
27};
28use swiftness_pow::{
29    config::Config as PowConfigVerifier, pow::UnsentCommitment as PowUnsentCommitmentVerifier,
30};
31use swiftness_proof_parser::{self, stark_proof};
32use swiftness_stark::{
33    config::StarkConfig as StarkConfigVerifier,
34    types::{
35        StarkProof as StarkProofVerifier, StarkUnsentCommitment as StarkUnsentCommitmentVerifier,
36        StarkWitness as StarkWitnessVerifier,
37    },
38};
39
40pub trait TransformTo<T> {
41    fn transform_to(self) -> T;
42}
43
44impl TransformTo<StarkProofVerifier> for stark_proof::StarkProof {
45    fn transform_to(self) -> StarkProofVerifier {
46        StarkProofVerifier {
47            config: self.config.transform_to(),
48            public_input: self.public_input.transform_to(),
49            unsent_commitment: self.unsent_commitment.transform_to(),
50            witness: self.witness.transform_to(),
51        }
52    }
53}
54
55impl TransformTo<StarkConfigVerifier> for stark_proof::StarkConfig {
56    fn transform_to(self) -> StarkConfigVerifier {
57        StarkConfigVerifier {
58            traces: self.traces.transform_to(),
59            composition: self.composition.transform_to(),
60            fri: self.fri.transform_to(),
61            proof_of_work: self.proof_of_work.transform_to(),
62            log_trace_domain_size: self.log_trace_domain_size.into(),
63            n_queries: self.n_queries.into(),
64            log_n_cosets: self.log_n_cosets.into(),
65            n_verifier_friendly_commitment_layers: self
66                .n_verifier_friendly_commitment_layers
67                .into(),
68        }
69    }
70}
71
72impl TransformTo<PowConfigVerifier> for stark_proof::ProofOfWorkConfig {
73    fn transform_to(self) -> PowConfigVerifier {
74        PowConfigVerifier { n_bits: self.n_bits as u8 }
75    }
76}
77
78impl TransformTo<FriConfigVerifier> for stark_proof::FriConfig {
79    fn transform_to(self) -> FriConfigVerifier {
80        FriConfigVerifier {
81            log_input_size: self.log_input_size.into(),
82            n_layers: self.n_layers.into(),
83            inner_layers: self.inner_layers.into_iter().map(|x| x.transform_to()).collect(),
84            fri_step_sizes: self.fri_step_sizes.into_iter().map(|x| x.into()).collect(),
85            log_last_layer_degree_bound: self.log_last_layer_degree_bound.into(),
86        }
87    }
88}
89
90impl TransformTo<TraceConfigVerifier> for stark_proof::TracesConfig {
91    fn transform_to(self) -> TraceConfigVerifier {
92        TraceConfigVerifier {
93            original: self.original.transform_to(),
94            interaction: self.interaction.transform_to(),
95        }
96    }
97}
98
99impl TransformTo<TableConfigVerifier> for stark_proof::TableCommitmentConfig {
100    fn transform_to(self) -> TableConfigVerifier {
101        TableConfigVerifier { n_columns: self.n_columns.into(), vector: self.vector.transform_to() }
102    }
103}
104
105impl TransformTo<VectorConfigVerifier> for stark_proof::VectorCommitmentConfig {
106    fn transform_to(self) -> VectorConfigVerifier {
107        VectorConfigVerifier {
108            height: self.height.into(),
109            n_verifier_friendly_commitment_layers: self
110                .n_verifier_friendly_commitment_layers
111                .into(),
112        }
113    }
114}
115
116impl TransformTo<PublicInputVerifier> for stark_proof::PublicInput {
117    fn transform_to(self) -> PublicInputVerifier {
118        let dynamic_params = match self.dynamic_params.is_empty() {
119            true => None,
120            false => {
121                let params: Vec<u32> = self.dynamic_params.values().cloned().collect();
122                Some(DynamicParams::from(params))
123            }
124        };
125
126        PublicInputVerifier {
127            log_n_steps: self.log_n_steps.into(),
128            range_check_min: self.range_check_min.into(),
129            range_check_max: self.range_check_max.into(),
130            layout: self.layout.into(),
131            dynamic_params,
132            segments: self.segments.into_iter().map(|x| x.transform_to()).collect(),
133            padding_addr: self.padding_addr.into(),
134            padding_value: self.padding_value.into(),
135            main_page: Page(self.main_page.into_iter().map(|x| x.transform_to()).collect()),
136            continuous_page_headers: vec![],
137        }
138    }
139}
140
141impl TransformTo<SegmentInfoVerifier> for stark_proof::SegmentInfo {
142    fn transform_to(self) -> SegmentInfoVerifier {
143        SegmentInfoVerifier { begin_addr: self.begin_addr.into(), stop_ptr: self.stop_ptr.into() }
144    }
145}
146
147impl TransformTo<AddrValue> for stark_proof::PubilcMemoryCell {
148    fn transform_to(self) -> AddrValue {
149        AddrValue { address: self.address.into(), value: self.value.into() }
150    }
151}
152
153impl TransformTo<StarkUnsentCommitmentVerifier> for stark_proof::StarkUnsentCommitment {
154    fn transform_to(self) -> StarkUnsentCommitmentVerifier {
155        StarkUnsentCommitmentVerifier {
156            traces: self.traces.transform_to(),
157            composition: self.composition.into(),
158            oods_values: self.oods_values.into_iter().map(|x| x.into()).collect(),
159            fri: self.fri.transform_to(),
160            proof_of_work: self.proof_of_work.transform_to(),
161        }
162    }
163}
164
165impl TransformTo<TraceUnsentCommitmentVerifier> for stark_proof::TracesUnsentCommitment {
166    fn transform_to(self) -> TraceUnsentCommitmentVerifier {
167        TraceUnsentCommitmentVerifier {
168            original: self.original.into(),
169            interaction: self.interaction.into(),
170        }
171    }
172}
173
174impl TransformTo<FriUnsentCommitmentVerifier> for stark_proof::FriUnsentCommitment {
175    fn transform_to(self) -> FriUnsentCommitmentVerifier {
176        FriUnsentCommitmentVerifier {
177            last_layer_coefficients: self
178                .last_layer_coefficients
179                .into_iter()
180                .map(|x| x.into())
181                .collect(),
182            inner_layers: self.inner_layers.into_iter().map(|x| x.into()).collect(),
183        }
184    }
185}
186
187impl TransformTo<PowUnsentCommitmentVerifier> for stark_proof::ProofOfWorkUnsentCommitment {
188    fn transform_to(self) -> PowUnsentCommitmentVerifier {
189        PowUnsentCommitmentVerifier { nonce: self.nonce.to_u64_digits()[0] }
190    }
191}
192
193impl TransformTo<StarkWitnessVerifier> for stark_proof::StarkWitness {
194    fn transform_to(self) -> StarkWitnessVerifier {
195        StarkWitnessVerifier {
196            traces_decommitment: self.traces_decommitment.transform_to(),
197            traces_witness: self.traces_witness.transform_to(),
198            composition_decommitment: self.composition_decommitment.transform_to(),
199            composition_witness: self.composition_witness.transform_to(),
200            fri_witness: self.fri_witness.transform_to(),
201        }
202    }
203}
204
205impl TransformTo<TraceDecommitmentVerifier> for stark_proof::TracesDecommitment {
206    fn transform_to(self) -> TraceDecommitmentVerifier {
207        TraceDecommitmentVerifier {
208            original: self.original.transform_to(),
209            interaction: self.interaction.transform_to(),
210        }
211    }
212}
213
214impl TransformTo<TableDecommitmentVerifier> for stark_proof::TableDecommitment {
215    fn transform_to(self) -> TableDecommitmentVerifier {
216        TableDecommitmentVerifier { values: self.values.into_iter().map(|x| x.into()).collect() }
217    }
218}
219
220impl TransformTo<TraceWitnessVerifier> for stark_proof::TracesWitness {
221    fn transform_to(self) -> TraceWitnessVerifier {
222        TraceWitnessVerifier {
223            original: self.original.transform_to(),
224            interaction: self.interaction.transform_to(),
225        }
226    }
227}
228
229impl TransformTo<TableCommitmentWitnessVerifier> for stark_proof::TableCommitmentWitness {
230    fn transform_to(self) -> TableCommitmentWitnessVerifier {
231        TableCommitmentWitnessVerifier { vector: self.vector.transform_to() }
232    }
233}
234
235impl TransformTo<VectorCommitmentWitnessVerifier> for stark_proof::VectorCommitmentWitness {
236    fn transform_to(self) -> VectorCommitmentWitnessVerifier {
237        VectorCommitmentWitnessVerifier {
238            authentications: self.authentications.into_iter().map(|x| x.into()).collect(),
239        }
240    }
241}
242
243impl TransformTo<FriWitnessVerifier> for stark_proof::FriWitness {
244    fn transform_to(self) -> FriWitnessVerifier {
245        FriWitnessVerifier { layers: self.layers.into_iter().map(|x| x.transform_to()).collect() }
246    }
247}
248
249impl TransformTo<LayerWitness> for stark_proof::FriLayerWitness {
250    fn transform_to(self) -> LayerWitness {
251        LayerWitness {
252            leaves: self.leaves.into_iter().map(|x| x.into()).collect(),
253            table_witness: self.table_witness.transform_to(),
254        }
255    }
256}
257
258impl TransformTo<TableCommitmentWitnessVerifier> for stark_proof::TableCommitmentWitnessFlat {
259    fn transform_to(self) -> TableCommitmentWitnessVerifier {
260        TableCommitmentWitnessVerifier { vector: self.vector.transform_to() }
261    }
262}
263
264impl TransformTo<VectorCommitmentWitnessVerifier> for stark_proof::VectorCommitmentWitnessFlat {
265    fn transform_to(self) -> VectorCommitmentWitnessVerifier {
266        VectorCommitmentWitnessVerifier {
267            authentications: self.authentications.into_iter().map(|x| x.into()).collect(),
268        }
269    }
270}
swiftness/transform.rs

swiftness/
transform.rs
