fullcodec_plonk/proof_system/
widget.rs

1// This Source Code Form is subject to the terms of the Mozilla Public
2// License, v. 2.0. If a copy of the MPL was not distributed with this
3// file, You can obtain one at http://mozilla.org/MPL/2.0/.
4//
5// Copyright (c) DUSK NETWORK. All rights reserved.
6
7use crate::commitment_scheme::Commitment;
8use dusk_bytes::{DeserializableSlice, Serializable};
9use parity_scale_codec::{Decode, Encode};
10
11pub mod arithmetic;
12pub mod ecc;
13pub mod logic;
14pub mod lookup;
15pub mod permutation;
16pub mod range;
17
18/// PLONK circuit Verification Key.
19///
20/// This structure is used by the Verifier in order to verify a
21/// [`Proof`](super::Proof).
22#[derive(Debug, PartialEq, Eq, Copy, Clone, Decode, Encode)]
23pub struct VerifierKey {
24    /// Circuit size (not padded to a power of two).
25    pub(crate) n: u32,
26    /// VerifierKey for arithmetic gates
27    pub(crate) arithmetic: arithmetic::VerifierKey,
28    /// VerifierKey for logic gates
29    pub(crate) logic: logic::VerifierKey,
30    /// VerifierKey for range gates
31    pub(crate) range: range::VerifierKey,
32    /// VerifierKey for fixed base curve addition gates
33    pub(crate) fixed_base: ecc::scalar_mul::fixed_base::VerifierKey,
34    /// VerifierKey for variable base curve addition gates
35    pub(crate) variable_base: ecc::curve_addition::VerifierKey,
36    /// VerifierKey for lookup operations
37    pub(crate) lookup: lookup::VerifierKey,
38    /// VerifierKey for permutation checks
39    pub(crate) permutation: permutation::VerifierKey,
40}
41
42impl Serializable<{ 20 * Commitment::SIZE + u64::SIZE }> for VerifierKey {
43    type Error = dusk_bytes::Error;
44
45    #[allow(unused_must_use)]
46    fn to_bytes(&self) -> [u8; Self::SIZE] {
47        use dusk_bytes::Write;
48        let mut buff = [0u8; Self::SIZE];
49        let mut writer = &mut buff[..];
50
51        writer.write(&(self.n as u64).to_bytes());
52        writer.write(&self.arithmetic.q_m.to_bytes());
53        writer.write(&self.arithmetic.q_l.to_bytes());
54        writer.write(&self.arithmetic.q_r.to_bytes());
55        writer.write(&self.arithmetic.q_o.to_bytes());
56        writer.write(&self.arithmetic.q_4.to_bytes());
57        writer.write(&self.arithmetic.q_c.to_bytes());
58        writer.write(&self.arithmetic.q_arith.to_bytes());
59        writer.write(&self.logic.q_logic.to_bytes());
60        writer.write(&self.range.q_range.to_bytes());
61        writer.write(&self.fixed_base.q_fixed_group_add.to_bytes());
62        writer.write(&self.variable_base.q_variable_group_add.to_bytes());
63        writer.write(&self.lookup.q_lookup.to_bytes());
64        writer.write(&self.permutation.left_sigma.to_bytes());
65        writer.write(&self.permutation.right_sigma.to_bytes());
66        writer.write(&self.permutation.out_sigma.to_bytes());
67        writer.write(&self.permutation.fourth_sigma.to_bytes());
68        writer.write(&self.lookup.table_1.to_bytes());
69        writer.write(&self.lookup.table_2.to_bytes());
70        writer.write(&self.lookup.table_3.to_bytes());
71        writer.write(&self.lookup.table_4.to_bytes());
72
73        buff
74    }
75
76    fn from_bytes(buf: &[u8; Self::SIZE]) -> Result<VerifierKey, Self::Error> {
77        let mut buffer = &buf[..];
78
79        Ok(Self::from_polynomial_commitments(
80            u64::from_reader(&mut buffer)? as usize,
81            Commitment::from_reader(&mut buffer)?,
82            Commitment::from_reader(&mut buffer)?,
83            Commitment::from_reader(&mut buffer)?,
84            Commitment::from_reader(&mut buffer)?,
85            Commitment::from_reader(&mut buffer)?,
86            Commitment::from_reader(&mut buffer)?,
87            Commitment::from_reader(&mut buffer)?,
88            Commitment::from_reader(&mut buffer)?,
89            Commitment::from_reader(&mut buffer)?,
90            Commitment::from_reader(&mut buffer)?,
91            Commitment::from_reader(&mut buffer)?,
92            Commitment::from_reader(&mut buffer)?,
93            Commitment::from_reader(&mut buffer)?,
94            Commitment::from_reader(&mut buffer)?,
95            Commitment::from_reader(&mut buffer)?,
96            Commitment::from_reader(&mut buffer)?,
97            Commitment::from_reader(&mut buffer)?,
98            Commitment::from_reader(&mut buffer)?,
99            Commitment::from_reader(&mut buffer)?,
100            Commitment::from_reader(&mut buffer)?,
101        ))
102    }
103}
104
105impl VerifierKey {
106    /// Returns the Circuit size padded to the next power of two.
107    pub const fn padded_gates(&self) -> u32 {
108        self.n.next_power_of_two()
109    }
110
111    /// Constructs a [`VerifierKey`] from the widget VerifierKey's that are
112    /// constructed based on the selector polynomial commitments and the
113    /// sigma polynomial commitments.
114    pub(crate) fn from_polynomial_commitments(
115        n: usize,
116        q_m: Commitment,
117        q_l: Commitment,
118        q_r: Commitment,
119        q_o: Commitment,
120        q_4: Commitment,
121        q_c: Commitment,
122        q_arith: Commitment,
123        q_logic: Commitment,
124        q_range: Commitment,
125        q_fixed_group_add: Commitment,
126        q_variable_group_add: Commitment,
127        q_lookup: Commitment,
128        left_sigma: Commitment,
129        right_sigma: Commitment,
130        out_sigma: Commitment,
131        fourth_sigma: Commitment,
132        table_1: Commitment,
133        table_2: Commitment,
134        table_3: Commitment,
135        table_4: Commitment,
136    ) -> VerifierKey {
137        let arithmetic = arithmetic::VerifierKey {
138            q_m,
139            q_l,
140            q_r,
141            q_o,
142            q_4,
143            q_c,
144            q_arith,
145        };
146        let logic = logic::VerifierKey { q_c, q_logic };
147        let range = range::VerifierKey { q_range };
148        let fixed_base = ecc::scalar_mul::fixed_base::VerifierKey {
149            q_l,
150            q_r,
151            q_fixed_group_add,
152        };
153
154        let variable_base = ecc::curve_addition::VerifierKey {
155            q_variable_group_add,
156        };
157
158        let lookup = lookup::VerifierKey {
159            q_lookup,
160            table_1,
161            table_2,
162            table_3,
163            table_4,
164        };
165
166        let permutation = permutation::VerifierKey {
167            left_sigma,
168            right_sigma,
169            out_sigma,
170            fourth_sigma,
171        };
172
173        let n = n as u32;
174
175        VerifierKey {
176            n,
177            arithmetic,
178            logic,
179            range,
180            fixed_base,
181            variable_base,
182            lookup,
183            permutation,
184        }
185    }
186}
187
188use crate::plonkup::MultiSet;
189use crate::{
190    error::Error,
191    fft::{EvaluationDomain, Evaluations, Polynomial},
192    transcript::TranscriptProtocol,
193};
194use dusk_bls12_381::BlsScalar;
195use merlin::Transcript;
196use sp_std::vec;
197use sp_std::vec::Vec;
198
199impl VerifierKey {
200    /// Adds the circuit description to the transcript
201    pub(crate) fn seed_transcript(&self, transcript: &mut Transcript) {
202        transcript.append_commitment(b"q_m", &self.arithmetic.q_m);
203        transcript.append_commitment(b"q_l", &self.arithmetic.q_l);
204        transcript.append_commitment(b"q_r", &self.arithmetic.q_r);
205        transcript.append_commitment(b"q_o", &self.arithmetic.q_o);
206        transcript.append_commitment(b"q_c", &self.arithmetic.q_c);
207        transcript.append_commitment(b"q_4", &self.arithmetic.q_4);
208        transcript.append_commitment(b"q_arith", &self.arithmetic.q_arith);
209        transcript.append_commitment(b"q_range", &self.range.q_range);
210        transcript.append_commitment(b"q_logic", &self.logic.q_logic);
211        transcript.append_commitment(
212            b"q_variable_group_add",
213            &self.variable_base.q_variable_group_add,
214        );
215        transcript.append_commitment(
216            b"q_fixed_group_add",
217            &self.fixed_base.q_fixed_group_add,
218        );
219
220        transcript
221            .append_commitment(b"left_sigma", &self.permutation.left_sigma);
222        transcript
223            .append_commitment(b"right_sigma", &self.permutation.right_sigma);
224        transcript.append_commitment(b"out_sigma", &self.permutation.out_sigma);
225        transcript
226            .append_commitment(b"fourth_sigma", &self.permutation.fourth_sigma);
227
228        // Append circuit size to transcript
229        transcript.circuit_domain_sep(self.n as u64);
230    }
231}
232
233/// PLONK circuit Proving Key.
234///
235/// This structure is used by the Prover in order to construct a
236/// [`Proof`](crate::proof_system::Proof).
237#[derive(Debug, PartialEq, Eq, Clone)]
238pub struct ProverKey {
239    /// Circuit size
240    pub(crate) n: usize,
241    /// ProverKey for arithmetic gate
242    pub(crate) arithmetic: arithmetic::ProverKey,
243    /// ProverKey for logic gate
244    pub(crate) logic: logic::ProverKey,
245    /// ProverKey for range gate
246    pub(crate) range: range::ProverKey,
247    /// ProverKey for fixed base curve addition gates
248    pub(crate) fixed_base: ecc::scalar_mul::fixed_base::ProverKey,
249    /// ProverKey for variable base curve addition gates
250    pub(crate) variable_base: ecc::curve_addition::ProverKey,
251    /// ProverKey for lookup gates
252    pub(crate) lookup: lookup::ProverKey,
253    /// ProverKey for permutation checks
254    pub(crate) permutation: permutation::ProverKey,
255    // Pre-processes the 4n Evaluations for the vanishing polynomial, so
256    // they do not need to be computed at the proving stage.
257    // Note: With this, we can combine all parts of the quotient polynomial
258    // in their evaluation phase and divide by the quotient
259    // polynomial without having to perform IFFT
260    pub(crate) v_h_coset_4n: Evaluations,
261}
262
263impl ProverKey {
264    /// Returns the number of [`Polynomial`]s contained in a ProverKey.
265    const fn num_polys() -> usize {
266        15
267    }
268
269    /// Returns the number of [`MultiSet`]s contained in a ProverKey.
270    const fn num_multiset() -> usize {
271        // FIXME https://github.com/dusk-network/plonk/issues/581
272        4
273    }
274
275    /// Returns the number of [`Evaluations`] contained in a ProverKey.
276    const fn num_evals() -> usize {
277        21
278    }
279
280    /// Serialises a [`ProverKey`] struct into a Vec of bytes.
281    #[allow(unused_must_use)]
282    pub fn to_var_bytes(&self) -> Vec<u8> {
283        use dusk_bytes::Write;
284        // Fetch size in bytes of each Polynomial
285        let poly_size = self.arithmetic.q_m.0.len() * BlsScalar::SIZE;
286        // Fetch size in bytes of each Evaluations
287        let evals_size = self.arithmetic.q_m.1.evals.len() * BlsScalar::SIZE
288            + EvaluationDomain::SIZE;
289
290        // Fetch size in bytes of each MultiSet combo: (MultiSet,
291        // Polynomial, Evaluations)
292        let multiset_size = self.lookup.table_1.0 .0.len() * BlsScalar::SIZE
293            + poly_size
294            + evals_size;
295
296        // Create the vec with the capacity counting the 3 u64's plus the 15
297        // Polys and the 17 Evaluations.
298        let mut bytes = vec![
299            0u8;
300            (Self::num_polys() * poly_size
301                + evals_size * Self::num_evals()
302                + multiset_size * Self::num_multiset()
303                + 17 * u64::SIZE) as usize
304        ];
305
306        let mut writer = &mut bytes[..];
307        writer.write(&(self.n as u64).to_bytes());
308        // Write Evaluation len in bytes.
309        writer.write(&(evals_size as u64).to_bytes());
310
311        // Arithmetic
312        writer.write(&(self.arithmetic.q_m.0.len() as u64).to_bytes());
313        writer.write(&self.arithmetic.q_m.0.to_var_bytes());
314        writer.write(&self.arithmetic.q_m.1.to_var_bytes());
315
316        writer.write(&(self.arithmetic.q_l.0.len() as u64).to_bytes());
317        writer.write(&self.arithmetic.q_l.0.to_var_bytes());
318        writer.write(&self.arithmetic.q_l.1.to_var_bytes());
319
320        writer.write(&(self.arithmetic.q_r.0.len() as u64).to_bytes());
321        writer.write(&self.arithmetic.q_r.0.to_var_bytes());
322        writer.write(&self.arithmetic.q_r.1.to_var_bytes());
323
324        writer.write(&(self.arithmetic.q_o.0.len() as u64).to_bytes());
325        writer.write(&self.arithmetic.q_o.0.to_var_bytes());
326        writer.write(&self.arithmetic.q_o.1.to_var_bytes());
327
328        writer.write(&(self.arithmetic.q_4.0.len() as u64).to_bytes());
329        writer.write(&self.arithmetic.q_4.0.to_var_bytes());
330        writer.write(&self.arithmetic.q_4.1.to_var_bytes());
331
332        writer.write(&(self.arithmetic.q_c.0.len() as u64).to_bytes());
333        writer.write(&self.arithmetic.q_c.0.to_var_bytes());
334        writer.write(&self.arithmetic.q_c.1.to_var_bytes());
335
336        writer.write(&(self.arithmetic.q_arith.0.len() as u64).to_bytes());
337        writer.write(&self.arithmetic.q_arith.0.to_var_bytes());
338        writer.write(&self.arithmetic.q_arith.1.to_var_bytes());
339
340        // Logic
341        writer.write(&(self.logic.q_logic.0.len() as u64).to_bytes());
342        writer.write(&self.logic.q_logic.0.to_var_bytes());
343        writer.write(&self.logic.q_logic.1.to_var_bytes());
344
345        // Range
346        writer.write(&(self.range.q_range.0.len() as u64).to_bytes());
347        writer.write(&self.range.q_range.0.to_var_bytes());
348        writer.write(&self.range.q_range.1.to_var_bytes());
349
350        // Fixed base multiplication
351        writer.write(
352            &(self.fixed_base.q_fixed_group_add.0.len() as u64).to_bytes(),
353        );
354        writer.write(&self.fixed_base.q_fixed_group_add.0.to_var_bytes());
355        writer.write(&self.fixed_base.q_fixed_group_add.1.to_var_bytes());
356
357        // Witness base addition
358        writer.write(
359            &(self.variable_base.q_variable_group_add.0.len() as u64)
360                .to_bytes(),
361        );
362        writer.write(&self.variable_base.q_variable_group_add.0.to_var_bytes());
363        writer.write(&self.variable_base.q_variable_group_add.1.to_var_bytes());
364
365        // Lookup
366        writer.write(&(self.lookup.q_lookup.0.len() as u64).to_bytes());
367        writer.write(&self.lookup.q_lookup.0.to_var_bytes());
368        writer.write(&self.lookup.q_lookup.1.to_var_bytes());
369
370        writer.write(&(self.lookup.table_1.0.len() as u64).to_bytes());
371        writer.write(&(self.lookup.table_1.0).to_var_bytes());
372        writer.write(&(self.lookup.table_1.1.len() as u64).to_bytes());
373        writer.write(&(self.lookup.table_1.1).to_var_bytes());
374        writer.write(&(self.lookup.table_1.2).to_var_bytes());
375
376        writer.write(&(self.lookup.table_2.0.len() as u64).to_bytes());
377        writer.write(&(self.lookup.table_2.0).to_var_bytes());
378        writer.write(&(self.lookup.table_2.1.len() as u64).to_bytes());
379        writer.write(&(self.lookup.table_2.1).to_var_bytes());
380        writer.write(&(self.lookup.table_2.2).to_var_bytes());
381
382        writer.write(&(self.lookup.table_3.0.len() as u64).to_bytes());
383        writer.write(&(self.lookup.table_3.0).to_var_bytes());
384        writer.write(&(self.lookup.table_3.1.len() as u64).to_bytes());
385        writer.write(&(self.lookup.table_3.1).to_var_bytes());
386        writer.write(&(self.lookup.table_3.2).to_var_bytes());
387
388        writer.write(&(self.lookup.table_4.0.len() as u64).to_bytes());
389        writer.write(&(self.lookup.table_4.0).to_var_bytes());
390        writer.write(&(self.lookup.table_4.1.len() as u64).to_bytes());
391        writer.write(&(self.lookup.table_4.1).to_var_bytes());
392        writer.write(&(self.lookup.table_4.2).to_var_bytes());
393
394        // Permutation
395        writer.write(&(self.permutation.left_sigma.0.len() as u64).to_bytes());
396        writer.write(&self.permutation.left_sigma.0.to_var_bytes());
397        writer.write(&self.permutation.left_sigma.1.to_var_bytes());
398
399        writer.write(&(self.permutation.right_sigma.0.len() as u64).to_bytes());
400        writer.write(&self.permutation.right_sigma.0.to_var_bytes());
401        writer.write(&self.permutation.right_sigma.1.to_var_bytes());
402
403        writer.write(&(self.permutation.out_sigma.0.len() as u64).to_bytes());
404        writer.write(&self.permutation.out_sigma.0.to_var_bytes());
405        writer.write(&self.permutation.out_sigma.1.to_var_bytes());
406
407        writer
408            .write(&(self.permutation.fourth_sigma.0.len() as u64).to_bytes());
409        writer.write(&self.permutation.fourth_sigma.0.to_var_bytes());
410        writer.write(&self.permutation.fourth_sigma.1.to_var_bytes());
411
412        writer.write(&self.permutation.linear_evaluations.to_var_bytes());
413
414        writer.write(&self.v_h_coset_4n.to_var_bytes());
415
416        bytes
417    }
418
419    /// Deserialises a slice of bytes into a [`ProverKey`].
420    pub fn from_slice(bytes: &[u8]) -> Result<ProverKey, Error> {
421        let mut buffer = bytes;
422        let n = u64::from_reader(&mut buffer)? as usize;
423        let evaluations_size = u64::from_reader(&mut buffer)? as usize;
424        // let domain = crate::fft::EvaluationDomain::new(4 * size)?;
425        // TODO: By creating this we can avoid including the
426        // EvaluationDomain inside Evaluations. See:
427        // dusk-network/plonk#436
428
429        let poly_from_reader = |buf: &mut &[u8]| -> Result<Polynomial, Error> {
430            let serialized_poly_len =
431                u64::from_reader(buf)? as usize * BlsScalar::SIZE;
432            // If the announced len is zero, simply return an empty poly
433            // and leave the buffer intact.
434            if serialized_poly_len == 0 {
435                return Ok(Polynomial { coeffs: vec![] });
436            }
437            let (a, b) = buf.split_at(serialized_poly_len);
438            let poly = Polynomial::from_slice(a);
439            *buf = b;
440
441            poly
442        };
443
444        let evals_from_reader =
445            |buf: &mut &[u8]| -> Result<Evaluations, Error> {
446                let (a, b) = buf.split_at(evaluations_size);
447                let eval = Evaluations::from_slice(a);
448                *buf = b;
449
450                eval
451            };
452
453        let multiset_from_reader =
454            |buf: &mut &[u8]| -> Result<MultiSet, Error> {
455                let serialized_multiset_len =
456                    u64::from_reader(buf)? as usize * BlsScalar::SIZE;
457                // If the announced len is zero, simply return an empty
458                // MultiSet and leave the buffer intact.
459                if serialized_multiset_len == 0 {
460                    return Ok(MultiSet::new());
461                }
462                let (a, b) = buf.split_at(serialized_multiset_len);
463                let multiset = MultiSet::from_slice(a);
464                *buf = b;
465
466                multiset
467            };
468
469        let q_m_poly = poly_from_reader(&mut buffer)?;
470        let q_m_evals = evals_from_reader(&mut buffer)?;
471        let q_m = (q_m_poly, q_m_evals);
472
473        let q_l_poly = poly_from_reader(&mut buffer)?;
474        let q_l_evals = evals_from_reader(&mut buffer)?;
475        let q_l = (q_l_poly, q_l_evals);
476
477        let q_r_poly = poly_from_reader(&mut buffer)?;
478        let q_r_evals = evals_from_reader(&mut buffer)?;
479        let q_r = (q_r_poly, q_r_evals);
480
481        let q_o_poly = poly_from_reader(&mut buffer)?;
482        let q_o_evals = evals_from_reader(&mut buffer)?;
483        let q_o = (q_o_poly, q_o_evals);
484
485        let q_4_poly = poly_from_reader(&mut buffer)?;
486        let q_4_evals = evals_from_reader(&mut buffer)?;
487        let q_4 = (q_4_poly, q_4_evals);
488
489        let q_c_poly = poly_from_reader(&mut buffer)?;
490        let q_c_evals = evals_from_reader(&mut buffer)?;
491        let q_c = (q_c_poly, q_c_evals);
492
493        let q_arith_poly = poly_from_reader(&mut buffer)?;
494        let q_arith_evals = evals_from_reader(&mut buffer)?;
495        let q_arith = (q_arith_poly, q_arith_evals);
496
497        let q_logic_poly = poly_from_reader(&mut buffer)?;
498        let q_logic_evals = evals_from_reader(&mut buffer)?;
499        let q_logic = (q_logic_poly, q_logic_evals);
500
501        let q_range_poly = poly_from_reader(&mut buffer)?;
502        let q_range_evals = evals_from_reader(&mut buffer)?;
503        let q_range = (q_range_poly, q_range_evals);
504
505        let q_fixed_group_add_poly = poly_from_reader(&mut buffer)?;
506        let q_fixed_group_add_evals = evals_from_reader(&mut buffer)?;
507        let q_fixed_group_add =
508            (q_fixed_group_add_poly, q_fixed_group_add_evals);
509
510        let q_variable_group_add_poly = poly_from_reader(&mut buffer)?;
511        let q_variable_group_add_evals = evals_from_reader(&mut buffer)?;
512        let q_variable_group_add =
513            (q_variable_group_add_poly, q_variable_group_add_evals);
514
515        let q_lookup_poly = poly_from_reader(&mut buffer)?;
516        let q_lookup_evals = evals_from_reader(&mut buffer)?;
517        let q_lookup = (q_lookup_poly, q_lookup_evals);
518
519        let table_1_multiset = multiset_from_reader(&mut buffer)?;
520        let table_1_poly = poly_from_reader(&mut buffer)?;
521        let table_1_evals = evals_from_reader(&mut buffer)?;
522        let table_1 = (table_1_multiset, table_1_poly, table_1_evals);
523
524        let table_2_multiset = multiset_from_reader(&mut buffer)?;
525        let table_2_poly = poly_from_reader(&mut buffer)?;
526        let table_2_evals = evals_from_reader(&mut buffer)?;
527        let table_2 = (table_2_multiset, table_2_poly, table_2_evals);
528
529        let table_3_multiset = multiset_from_reader(&mut buffer)?;
530        let table_3_poly = poly_from_reader(&mut buffer)?;
531        let table_3_evals = evals_from_reader(&mut buffer)?;
532        let table_3 = (table_3_multiset, table_3_poly, table_3_evals);
533
534        let table_4_multiset = multiset_from_reader(&mut buffer)?;
535        let table_4_poly = poly_from_reader(&mut buffer)?;
536        let table_4_evals = evals_from_reader(&mut buffer)?;
537        let table_4 = (table_4_multiset, table_4_poly, table_4_evals);
538
539        let left_sigma_poly = poly_from_reader(&mut buffer)?;
540        let left_sigma_evals = evals_from_reader(&mut buffer)?;
541        let left_sigma = (left_sigma_poly, left_sigma_evals);
542
543        let right_sigma_poly = poly_from_reader(&mut buffer)?;
544        let right_sigma_evals = evals_from_reader(&mut buffer)?;
545        let right_sigma = (right_sigma_poly, right_sigma_evals);
546
547        let out_sigma_poly = poly_from_reader(&mut buffer)?;
548        let out_sigma_evals = evals_from_reader(&mut buffer)?;
549        let out_sigma = (out_sigma_poly, out_sigma_evals);
550
551        let fourth_sigma_poly = poly_from_reader(&mut buffer)?;
552        let fourth_sigma_evals = evals_from_reader(&mut buffer)?;
553        let fourth_sigma = (fourth_sigma_poly, fourth_sigma_evals);
554
555        let perm_linear_evaluations = evals_from_reader(&mut buffer)?;
556
557        let v_h_coset_4n = evals_from_reader(&mut buffer)?;
558
559        let arithmetic = arithmetic::ProverKey {
560            q_m,
561            q_l: q_l.clone(),
562            q_r: q_r.clone(),
563            q_o,
564            q_c: q_c.clone(),
565            q_4,
566            q_arith,
567        };
568
569        let logic = logic::ProverKey {
570            q_logic,
571            q_c: q_c.clone(),
572        };
573
574        let range = range::ProverKey { q_range };
575
576        let fixed_base = ecc::scalar_mul::fixed_base::ProverKey {
577            q_l,
578            q_r,
579            q_c,
580            q_fixed_group_add,
581        };
582
583        let permutation = permutation::ProverKey {
584            left_sigma,
585            right_sigma,
586            out_sigma,
587            fourth_sigma,
588            linear_evaluations: perm_linear_evaluations,
589        };
590
591        let variable_base = ecc::curve_addition::ProverKey {
592            q_variable_group_add,
593        };
594
595        let lookup = lookup::ProverKey {
596            q_lookup,
597            table_1,
598            table_2,
599            table_3,
600            table_4,
601        };
602
603        let prover_key = ProverKey {
604            n,
605            arithmetic,
606            logic,
607            range,
608            fixed_base,
609            variable_base,
610            lookup,
611            permutation,
612            v_h_coset_4n,
613        };
614
615        Ok(prover_key)
616    }
617
618    pub(crate) fn v_h_coset_4n(&self) -> &Evaluations {
619        &self.v_h_coset_4n
620    }
621}
622
623#[cfg(feature = "std")]
624#[cfg(test)]
625mod test {
626    use super::ProverKey;
627    use super::*;
628    use crate::fft::{EvaluationDomain, Evaluations, Polynomial};
629    use crate::plonkup::MultiSet;
630    use dusk_bls12_381::BlsScalar;
631    use rand_core::OsRng;
632    use sp_std::vec::Vec;
633
634    fn rand_poly_eval(n: usize) -> (Polynomial, Evaluations) {
635        let polynomial = Polynomial::rand(n, &mut OsRng);
636        (polynomial, rand_evaluations(n))
637    }
638
639    fn rand_evaluations(n: usize) -> Evaluations {
640        let domain = EvaluationDomain::new(4 * n).unwrap();
641        let values: Vec<_> =
642            (0..4 * n).map(|_| BlsScalar::random(&mut OsRng)).collect();
643
644        Evaluations::from_vec_and_domain(values, domain)
645    }
646
647    fn rand_multiset(n: usize) -> (MultiSet, Polynomial, Evaluations) {
648        let values: Vec<_> =
649            (0..n).map(|_| BlsScalar::random(&mut OsRng)).collect();
650        let multiset = MultiSet(values);
651        let polynomial = Polynomial::rand(n, &mut OsRng);
652        (multiset, polynomial, rand_evaluations(n))
653    }
654
655    #[test]
656    fn test_serialise_deserialise_prover_key() {
657        let n = 1 << 11;
658
659        let q_m = rand_poly_eval(n);
660        let q_l = rand_poly_eval(n);
661        let q_r = rand_poly_eval(n);
662        let q_o = rand_poly_eval(n);
663        let q_c = rand_poly_eval(n);
664        let q_4 = rand_poly_eval(n);
665        let q_arith = rand_poly_eval(n);
666
667        let q_logic = rand_poly_eval(n);
668
669        let q_range = rand_poly_eval(n);
670
671        let q_lookup = rand_poly_eval(n);
672
673        let q_fixed_group_add = rand_poly_eval(n);
674
675        let q_variable_group_add = rand_poly_eval(n);
676
677        let left_sigma = rand_poly_eval(n);
678        let right_sigma = rand_poly_eval(n);
679        let out_sigma = rand_poly_eval(n);
680        let fourth_sigma = rand_poly_eval(n);
681        let linear_evaluations = rand_evaluations(n);
682
683        let table_1 = rand_multiset(n);
684        let table_2 = rand_multiset(n);
685        let table_3 = rand_multiset(n);
686        let table_4 = rand_multiset(n);
687
688        let v_h_coset_4n = rand_evaluations(n);
689
690        let arithmetic = arithmetic::ProverKey {
691            q_m,
692            q_l: q_l.clone(),
693            q_r: q_r.clone(),
694            q_o,
695            q_c: q_c.clone(),
696            q_4,
697            q_arith,
698        };
699
700        let logic = logic::ProverKey {
701            q_logic,
702            q_c: q_c.clone(),
703        };
704
705        let range = range::ProverKey { q_range };
706
707        let lookup = lookup::ProverKey {
708            q_lookup,
709            table_1,
710            table_2,
711            table_3,
712            table_4,
713        };
714
715        let fixed_base = ecc::scalar_mul::fixed_base::ProverKey {
716            q_fixed_group_add,
717            q_l,
718            q_r,
719            q_c,
720        };
721
722        let permutation = permutation::ProverKey {
723            left_sigma,
724            right_sigma,
725            out_sigma,
726            fourth_sigma,
727            linear_evaluations,
728        };
729
730        let variable_base = ecc::curve_addition::ProverKey {
731            q_variable_group_add,
732        };
733
734        let prover_key = ProverKey {
735            n,
736            arithmetic,
737            logic,
738            fixed_base,
739            range,
740            variable_base,
741            lookup,
742            permutation,
743            v_h_coset_4n,
744        };
745
746        let prover_key_bytes = prover_key.to_var_bytes();
747        let pk = ProverKey::from_slice(&prover_key_bytes).unwrap();
748
749        assert_eq!(pk, prover_key);
750        assert_eq!(pk.to_var_bytes(), prover_key.to_var_bytes());
751    }
752
753    #[test]
754    fn test_serialise_deserialise_verifier_key() {
755        use crate::commitment_scheme::Commitment;
756        use dusk_bls12_381::G1Affine;
757
758        let n = 2usize.pow(5) as u32;
759
760        let q_m = Commitment(G1Affine::generator());
761        let q_l = Commitment(G1Affine::generator());
762        let q_r = Commitment(G1Affine::generator());
763        let q_o = Commitment(G1Affine::generator());
764        let q_c = Commitment(G1Affine::generator());
765        let q_4 = Commitment(G1Affine::generator());
766        let q_arith = Commitment(G1Affine::generator());
767
768        let q_range = Commitment(G1Affine::generator());
769
770        let q_fixed_group_add = Commitment(G1Affine::generator());
771        let q_variable_group_add = Commitment(G1Affine::generator());
772
773        let q_logic = Commitment(G1Affine::generator());
774        let q_lookup = Commitment(G1Affine::generator());
775
776        let left_sigma = Commitment(G1Affine::generator());
777        let right_sigma = Commitment(G1Affine::generator());
778        let out_sigma = Commitment(G1Affine::generator());
779        let fourth_sigma = Commitment(G1Affine::generator());
780
781        let table_1 = Commitment(G1Affine::generator());
782        let table_2 = Commitment(G1Affine::generator());
783        let table_3 = Commitment(G1Affine::generator());
784        let table_4 = Commitment(G1Affine::generator());
785
786        let arithmetic = arithmetic::VerifierKey {
787            q_m,
788            q_l,
789            q_r,
790            q_o,
791            q_c,
792            q_4,
793            q_arith,
794        };
795
796        let logic = logic::VerifierKey { q_logic, q_c };
797
798        let range = range::VerifierKey { q_range };
799
800        let lookup = lookup::VerifierKey {
801            q_lookup,
802            table_1,
803            table_2,
804            table_3,
805            table_4,
806        };
807
808        let fixed_base = ecc::scalar_mul::fixed_base::VerifierKey {
809            q_fixed_group_add,
810            q_l,
811            q_r,
812        };
813        let variable_base = ecc::curve_addition::VerifierKey {
814            q_variable_group_add,
815        };
816
817        let permutation = permutation::VerifierKey {
818            left_sigma,
819            right_sigma,
820            out_sigma,
821            fourth_sigma,
822        };
823
824        let verifier_key = VerifierKey {
825            n,
826            arithmetic,
827            logic,
828            range,
829            fixed_base,
830            variable_base,
831            lookup,
832            permutation,
833        };
834
835        let verifier_key_bytes = verifier_key.to_bytes();
836        let got = VerifierKey::from_bytes(&verifier_key_bytes).unwrap();
837
838        assert_eq!(got, verifier_key);
839    }
840}
fullcodec_plonk/proof_system/widget.rs

fullcodec_plonk/proof_system/
widget.rs
