mina_tree/proofs/
constants.rs

1use ark_ff::{One, Zero};
2use mina_curves::pasta::{Fp, Fq};
3
4use super::{
5    field::Boolean,
6    step::{Basic, FeatureFlags, ForStep, ForStepKind, OptFlag},
7    transaction::CircuitPlonkVerificationKeyEvals,
8    wrap::{Domain, Domains},
9};
10
11pub trait ProofConstants {
12    /// Number of public inputs
13    const PRIMARY_LEN: usize;
14    /// Number of witness values
15    const AUX_LEN: usize;
16    const PREVIOUS_CHALLENGES: usize;
17    const ROWS: usize;
18}
19
20pub struct StepTransactionProof {}
21pub struct WrapTransactionProof {}
22
23pub struct StepBlockProof {}
24pub struct WrapBlockProof {}
25
26pub struct StepMergeProof {}
27pub struct WrapMergeProof {}
28
29pub struct StepZkappProvedProof {}
30pub struct StepZkappOptSignedProof {}
31pub struct StepZkappOptSignedOptSignedProof {}
32/// Using signature authorization
33pub struct WrapZkappProof {}
34/// Using proof authorization
35pub struct WrapZkappProvedProof {}
36pub struct WrapZkappOptSignedProof {}
37
38impl ProofConstants for StepZkappOptSignedOptSignedProof {
39    const PRIMARY_LEN: usize = 67;
40    const AUX_LEN: usize = 104914;
41    const PREVIOUS_CHALLENGES: usize = 0;
42    const ROWS: usize = 18655;
43}
44
45impl ProofConstants for StepZkappOptSignedProof {
46    const PRIMARY_LEN: usize = 67;
47    const AUX_LEN: usize = 71842;
48    const PREVIOUS_CHALLENGES: usize = 0;
49    const ROWS: usize = 11332;
50}
51
52impl ProofConstants for StepZkappProvedProof {
53    const PRIMARY_LEN: usize = 67;
54    const AUX_LEN: usize = 210350;
55    const PREVIOUS_CHALLENGES: usize = 1;
56    const ROWS: usize = 20023;
57}
58
59// Same values than `WrapTransactionProof`
60impl ProofConstants for WrapZkappProof {
61    const PRIMARY_LEN: usize = WrapTransactionProof::PRIMARY_LEN;
62    const AUX_LEN: usize = WrapTransactionProof::AUX_LEN;
63    const PREVIOUS_CHALLENGES: usize = WrapTransactionProof::PREVIOUS_CHALLENGES;
64    const ROWS: usize = WrapTransactionProof::ROWS;
65}
66
67// Same values than `WrapTransactionProof`
68impl ProofConstants for WrapZkappProvedProof {
69    const PRIMARY_LEN: usize = WrapTransactionProof::PRIMARY_LEN;
70    const AUX_LEN: usize = WrapTransactionProof::AUX_LEN;
71    const PREVIOUS_CHALLENGES: usize = WrapTransactionProof::PREVIOUS_CHALLENGES;
72    const ROWS: usize = WrapTransactionProof::ROWS;
73}
74
75// Same values than `WrapTransactionProof`
76impl ProofConstants for WrapZkappOptSignedProof {
77    const PRIMARY_LEN: usize = WrapTransactionProof::PRIMARY_LEN;
78    const AUX_LEN: usize = WrapTransactionProof::AUX_LEN;
79    const PREVIOUS_CHALLENGES: usize = WrapTransactionProof::PREVIOUS_CHALLENGES;
80    const ROWS: usize = WrapTransactionProof::ROWS;
81}
82
83impl ProofConstants for StepTransactionProof {
84    const PRIMARY_LEN: usize = 67;
85    const AUX_LEN: usize = 94478;
86    const PREVIOUS_CHALLENGES: usize = 0;
87    const ROWS: usize = 17806;
88}
89
90impl ProofConstants for WrapTransactionProof {
91    const PRIMARY_LEN: usize = 40;
92    const AUX_LEN: usize = 179491;
93    const PREVIOUS_CHALLENGES: usize = 2;
94    const ROWS: usize = 15122;
95}
96
97// Same values than `WrapTransactionProof`
98impl ProofConstants for WrapMergeProof {
99    const PRIMARY_LEN: usize = WrapTransactionProof::PRIMARY_LEN;
100    const AUX_LEN: usize = WrapTransactionProof::AUX_LEN;
101    const PREVIOUS_CHALLENGES: usize = WrapTransactionProof::PREVIOUS_CHALLENGES;
102    const ROWS: usize = WrapTransactionProof::ROWS;
103}
104
105impl ProofConstants for WrapBlockProof {
106    const PRIMARY_LEN: usize = 40;
107    const AUX_LEN: usize = 179208;
108    const PREVIOUS_CHALLENGES: usize = 2;
109    const ROWS: usize = 14657;
110}
111
112impl ProofConstants for StepMergeProof {
113    const PRIMARY_LEN: usize = 67;
114    const AUX_LEN: usize = 352469;
115    const PREVIOUS_CHALLENGES: usize = 2;
116    const ROWS: usize = 29010;
117}
118
119impl ProofConstants for StepBlockProof {
120    const PRIMARY_LEN: usize = 67;
121    const AUX_LEN: usize = 338873;
122    const PREVIOUS_CHALLENGES: usize = 2;
123    const ROWS: usize = 34797;
124}
125
126pub trait ForWrapData {
127    fn wrap_data() -> WrapData;
128}
129
130#[derive(Debug)]
131pub struct WrapData {
132    pub which_index: u64,
133    pub pi_branches: u64,
134    pub step_widths: Box<[u64]>, // TODO: Use array with size=pi_branches
135    pub step_domains: Box<[Domains]>, // Here too
136    pub wrap_domain_indices: Box<[Fq; 2]>,
137}
138
139impl ForWrapData for WrapTransactionProof {
140    fn wrap_data() -> WrapData {
141        WrapData {
142            which_index: 0,
143            pi_branches: 5,
144            step_widths: default_step_widths(),
145            step_domains: default_step_domains(),
146            wrap_domain_indices: default_wrap_domain_indices(),
147        }
148    }
149}
150
151impl ForWrapData for WrapZkappProof {
152    fn wrap_data() -> WrapData {
153        WrapData {
154            which_index: 2,
155            pi_branches: 5,
156            step_widths: default_step_widths(),
157            step_domains: default_step_domains(),
158            wrap_domain_indices: default_wrap_domain_indices(),
159        }
160    }
161}
162
163impl ForWrapData for WrapZkappProvedProof {
164    fn wrap_data() -> WrapData {
165        WrapData {
166            which_index: 4,
167            pi_branches: 5,
168            step_widths: default_step_widths(),
169            step_domains: default_step_domains(),
170            wrap_domain_indices: Box::new([Fq::one(), Fq::zero()]),
171        }
172    }
173}
174
175impl ForWrapData for WrapZkappOptSignedProof {
176    fn wrap_data() -> WrapData {
177        WrapData {
178            which_index: 3,
179            pi_branches: 5,
180            step_widths: default_step_widths(),
181            step_domains: default_step_domains(),
182            wrap_domain_indices: default_wrap_domain_indices(),
183        }
184    }
185}
186
187impl ForWrapData for WrapBlockProof {
188    fn wrap_data() -> WrapData {
189        WrapData {
190            which_index: 0,
191            pi_branches: 1,
192            step_widths: Box::new([2]),
193            step_domains: Box::new([Domains {
194                h: Domain::Pow2RootsOfUnity(16),
195            }]),
196            wrap_domain_indices: default_wrap_domain_indices(),
197        }
198    }
199}
200
201impl ForWrapData for WrapMergeProof {
202    fn wrap_data() -> WrapData {
203        WrapData {
204            which_index: 1,
205            pi_branches: 5,
206            step_widths: default_step_widths(),
207            step_domains: default_step_domains(),
208            wrap_domain_indices: default_wrap_domain_indices(),
209        }
210    }
211}
212
213fn default_step_domains() -> Box<[Domains]> {
214    Box::new([
215        Domains {
216            h: Domain::Pow2RootsOfUnity(15),
217        },
218        Domains {
219            h: Domain::Pow2RootsOfUnity(15),
220        },
221        Domains {
222            h: Domain::Pow2RootsOfUnity(15),
223        },
224        Domains {
225            h: Domain::Pow2RootsOfUnity(14),
226        },
227        Domains {
228            h: Domain::Pow2RootsOfUnity(15),
229        },
230    ])
231}
232
233fn default_wrap_domain_indices() -> Box<[Fq; 2]> {
234    Box::new([Fq::one(), Fq::one()])
235}
236
237fn default_step_widths() -> Box<[u64]> {
238    Box::new([0, 2, 0, 0, 1])
239}
240
241pub fn make_step_transaction_data(wrap_key: &CircuitPlonkVerificationKeyEvals<Fp>) -> ForStep {
242    let basic = Basic {
243        proof_verifieds: vec![0, 2, 0, 0, 1],
244        wrap_domain: Domains {
245            h: Domain::Pow2RootsOfUnity(14),
246        },
247        step_domains: default_step_domains(),
248        feature_flags: FeatureFlags {
249            range_check0: OptFlag::No,
250            range_check1: OptFlag::No,
251            foreign_field_add: OptFlag::No,
252            foreign_field_mul: OptFlag::No,
253            xor: OptFlag::No,
254            rot: OptFlag::No,
255            lookup: OptFlag::No,
256            runtime_tables: OptFlag::No,
257        },
258    };
259
260    let self_branches = 5;
261    let max_proofs_verified = 2;
262    let self_data = ForStep {
263        branches: self_branches,
264        max_proofs_verified,
265        proof_verifieds: ForStepKind::Known(
266            basic
267                .proof_verifieds
268                .iter()
269                .copied()
270                .map(Fp::from)
271                .collect(),
272        ),
273        public_input: (),
274        wrap_key: wrap_key.clone(), // TODO: Use ref
275        wrap_domain: ForStepKind::Known(basic.wrap_domain.h),
276        step_domains: ForStepKind::Known(basic.step_domains),
277        feature_flags: basic.feature_flags,
278        num_chunks: 1,
279        zk_rows: 3,
280    };
281
282    self_data
283}
284
285/// Zkapps using proof authorization
286pub fn make_step_zkapp_data(wrap_key: &CircuitPlonkVerificationKeyEvals<Fp>) -> ForStep {
287    let basic = Basic {
288        proof_verifieds: vec![0, 2, 0, 0, 1],
289        wrap_domain: Domains {
290            h: Domain::Pow2RootsOfUnity(15),
291        },
292        step_domains: default_step_domains(),
293        feature_flags: FeatureFlags {
294            range_check0: OptFlag::Maybe,
295            range_check1: OptFlag::Maybe,
296            foreign_field_add: OptFlag::Maybe,
297            foreign_field_mul: OptFlag::Maybe,
298            xor: OptFlag::Maybe,
299            rot: OptFlag::Maybe,
300            lookup: OptFlag::Maybe,
301            runtime_tables: OptFlag::Maybe,
302        },
303    };
304
305    let self_branches = 5; // 8 ?
306    let max_proofs_verified = 2;
307    let self_data = ForStep {
308        branches: self_branches,
309        max_proofs_verified,
310        proof_verifieds: ForStepKind::Known(
311            basic
312                .proof_verifieds
313                .iter()
314                .copied()
315                .map(Fp::from)
316                .collect(),
317        ),
318        public_input: (),
319        wrap_key: wrap_key.clone(), // TODO: Use ref
320        wrap_domain: ForStepKind::SideLoaded(Box::new([
321            Boolean::True,
322            Boolean::False,
323            Boolean::False,
324        ])),
325        step_domains: ForStepKind::SideLoaded(()),
326        feature_flags: basic.feature_flags,
327        num_chunks: 1,
328        zk_rows: 3,
329    };
330
331    self_data
332}
333
334pub fn make_step_block_data(wrap_key: &CircuitPlonkVerificationKeyEvals<Fp>) -> ForStep {
335    let basic = Basic {
336        proof_verifieds: vec![2],
337        wrap_domain: Domains {
338            h: Domain::Pow2RootsOfUnity(14),
339        },
340        step_domains: Box::new([Domains {
341            h: Domain::Pow2RootsOfUnity(16),
342        }]),
343        feature_flags: FeatureFlags {
344            range_check0: OptFlag::No,
345            range_check1: OptFlag::No,
346            foreign_field_add: OptFlag::No,
347            foreign_field_mul: OptFlag::No,
348            xor: OptFlag::No,
349            rot: OptFlag::No,
350            lookup: OptFlag::No,
351            runtime_tables: OptFlag::No,
352        },
353    };
354
355    let self_branches = 1;
356    let max_proofs_verified = 2;
357    let self_data = ForStep {
358        branches: self_branches,
359        max_proofs_verified,
360        proof_verifieds: ForStepKind::Known(
361            basic
362                .proof_verifieds
363                .iter()
364                .copied()
365                .map(Fp::from)
366                .collect(),
367        ),
368        public_input: (),
369        wrap_key: wrap_key.clone(), // TODO: Use ref
370        wrap_domain: ForStepKind::Known(basic.wrap_domain.h),
371        step_domains: ForStepKind::Known(basic.step_domains),
372        feature_flags: basic.feature_flags,
373        num_chunks: 1,
374        zk_rows: 3,
375    };
376
377    self_data
378}
mina_tree/proofs/constants.rs

mina_tree/proofs/
constants.rs
