dory_pcs/backends/arkworks/
ark_serde.rs

1//! Manual implementations of Dory serialization traits for arkworks wrapper types
2use crate::backends::arkworks::{ArkFr, ArkG1, ArkG2, ArkGT};
3use crate::primitives::serialization::{Compress, SerializationError, Valid, Validate};
4use crate::primitives::{DoryDeserialize, DorySerialize};
5use ark_serialize::{
6    CanonicalDeserialize, CanonicalSerialize, Compress as ArkCompress,
7    SerializationError as ArkSerializationError, Valid as ArkValid, Validate as ArkValidate,
8};
9use std::io::{Read, Write};
10
11use super::BN254;
12use crate::messages::{FirstReduceMessage, ScalarProductMessage, SecondReduceMessage, VMVMessage};
13use crate::setup::{ProverSetup, VerifierSetup};
14
15impl Valid for ArkFr {
16    fn check(&self) -> Result<(), SerializationError> {
17        self.0
18            .check()
19            .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))
20    }
21}
22
23impl DorySerialize for ArkFr {
24    fn serialize_with_mode<W: Write>(
25        &self,
26        writer: W,
27        compress: Compress,
28    ) -> Result<(), SerializationError> {
29        match compress {
30            Compress::Yes => self
31                .0
32                .serialize_compressed(writer)
33                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
34            Compress::No => self
35                .0
36                .serialize_uncompressed(writer)
37                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
38        }
39    }
40
41    fn serialized_size(&self, compress: Compress) -> usize {
42        match compress {
43            Compress::Yes => self.0.compressed_size(),
44            Compress::No => self.0.uncompressed_size(),
45        }
46    }
47}
48
49impl DoryDeserialize for ArkFr {
50    fn deserialize_with_mode<R: Read>(
51        reader: R,
52        compress: Compress,
53        validate: Validate,
54    ) -> Result<Self, SerializationError> {
55        let inner = match compress {
56            Compress::Yes => ark_bn254::Fr::deserialize_compressed(reader)
57                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
58            Compress::No => ark_bn254::Fr::deserialize_uncompressed(reader)
59                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
60        };
61
62        if matches!(validate, Validate::Yes) {
63            inner
64                .check()
65                .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))?;
66        }
67
68        Ok(ArkFr(inner))
69    }
70}
71
72impl Valid for ArkG1 {
73    fn check(&self) -> Result<(), SerializationError> {
74        self.0
75            .check()
76            .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))
77    }
78}
79
80impl DorySerialize for ArkG1 {
81    fn serialize_with_mode<W: Write>(
82        &self,
83        writer: W,
84        compress: Compress,
85    ) -> Result<(), SerializationError> {
86        match compress {
87            Compress::Yes => self
88                .0
89                .serialize_compressed(writer)
90                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
91            Compress::No => self
92                .0
93                .serialize_uncompressed(writer)
94                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
95        }
96    }
97
98    fn serialized_size(&self, compress: Compress) -> usize {
99        match compress {
100            Compress::Yes => self.0.compressed_size(),
101            Compress::No => self.0.uncompressed_size(),
102        }
103    }
104}
105
106impl DoryDeserialize for ArkG1 {
107    fn deserialize_with_mode<R: Read>(
108        reader: R,
109        compress: Compress,
110        validate: Validate,
111    ) -> Result<Self, SerializationError> {
112        let inner = match compress {
113            Compress::Yes => ark_bn254::G1Projective::deserialize_compressed(reader)
114                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
115            Compress::No => ark_bn254::G1Projective::deserialize_uncompressed(reader)
116                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
117        };
118
119        if matches!(validate, Validate::Yes) {
120            inner
121                .check()
122                .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))?;
123        }
124
125        Ok(ArkG1(inner))
126    }
127}
128
129impl Valid for ArkG2 {
130    fn check(&self) -> Result<(), SerializationError> {
131        self.0
132            .check()
133            .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))
134    }
135}
136
137impl DorySerialize for ArkG2 {
138    fn serialize_with_mode<W: Write>(
139        &self,
140        writer: W,
141        compress: Compress,
142    ) -> Result<(), SerializationError> {
143        match compress {
144            Compress::Yes => self
145                .0
146                .serialize_compressed(writer)
147                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
148            Compress::No => self
149                .0
150                .serialize_uncompressed(writer)
151                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
152        }
153    }
154
155    fn serialized_size(&self, compress: Compress) -> usize {
156        match compress {
157            Compress::Yes => self.0.compressed_size(),
158            Compress::No => self.0.uncompressed_size(),
159        }
160    }
161}
162
163impl DoryDeserialize for ArkG2 {
164    fn deserialize_with_mode<R: Read>(
165        reader: R,
166        compress: Compress,
167        validate: Validate,
168    ) -> Result<Self, SerializationError> {
169        let inner = match compress {
170            Compress::Yes => ark_bn254::G2Projective::deserialize_compressed(reader)
171                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
172            Compress::No => ark_bn254::G2Projective::deserialize_uncompressed(reader)
173                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
174        };
175
176        if matches!(validate, Validate::Yes) {
177            inner
178                .check()
179                .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))?;
180        }
181
182        Ok(ArkG2(inner))
183    }
184}
185
186impl Valid for ArkGT {
187    fn check(&self) -> Result<(), SerializationError> {
188        self.0
189            .check()
190            .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))
191    }
192}
193
194impl DorySerialize for ArkGT {
195    fn serialize_with_mode<W: Write>(
196        &self,
197        writer: W,
198        compress: Compress,
199    ) -> Result<(), SerializationError> {
200        match compress {
201            Compress::Yes => self
202                .0
203                .serialize_compressed(writer)
204                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
205            Compress::No => self
206                .0
207                .serialize_uncompressed(writer)
208                .map_err(|e| SerializationError::InvalidData(format!("{}", e))),
209        }
210    }
211
212    fn serialized_size(&self, compress: Compress) -> usize {
213        match compress {
214            Compress::Yes => self.0.compressed_size(),
215            Compress::No => self.0.uncompressed_size(),
216        }
217    }
218}
219
220impl DoryDeserialize for ArkGT {
221    fn deserialize_with_mode<R: Read>(
222        reader: R,
223        compress: Compress,
224        validate: Validate,
225    ) -> Result<Self, SerializationError> {
226        let inner = match compress {
227            Compress::Yes => ark_bn254::Fq12::deserialize_compressed(reader)
228                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
229            Compress::No => ark_bn254::Fq12::deserialize_uncompressed(reader)
230                .map_err(|e| SerializationError::InvalidData(format!("{}", e)))?,
231        };
232
233        if matches!(validate, Validate::Yes) {
234            inner
235                .check()
236                .map_err(|e| SerializationError::InvalidData(format!("{:?}", e)))?;
237        }
238
239        Ok(ArkGT(inner))
240    }
241}
242
243// Arkworks-specific Dory proof type
244use super::ArkDoryProof;
245
246impl ArkValid for ArkDoryProof {
247    fn check(&self) -> Result<(), ArkSerializationError> {
248        Ok(())
249    }
250}
251
252impl CanonicalSerialize for ArkDoryProof {
253    fn serialize_with_mode<W: Write>(
254        &self,
255        mut writer: W,
256        compress: ArkCompress,
257    ) -> Result<(), ArkSerializationError> {
258        // Serialize VMV message
259        CanonicalSerialize::serialize_with_mode(&self.vmv_message.c, &mut writer, compress)?;
260        CanonicalSerialize::serialize_with_mode(&self.vmv_message.d2, &mut writer, compress)?;
261        CanonicalSerialize::serialize_with_mode(&self.vmv_message.e1, &mut writer, compress)?;
262
263        // Serialize number of rounds
264        let num_rounds = self.first_messages.len() as u32;
265        CanonicalSerialize::serialize_with_mode(&num_rounds, &mut writer, compress)?;
266
267        // Serialize first messages
268        for msg in &self.first_messages {
269            CanonicalSerialize::serialize_with_mode(&msg.d1_left, &mut writer, compress)?;
270            CanonicalSerialize::serialize_with_mode(&msg.d1_right, &mut writer, compress)?;
271            CanonicalSerialize::serialize_with_mode(&msg.d2_left, &mut writer, compress)?;
272            CanonicalSerialize::serialize_with_mode(&msg.d2_right, &mut writer, compress)?;
273            CanonicalSerialize::serialize_with_mode(&msg.e1_beta, &mut writer, compress)?;
274            CanonicalSerialize::serialize_with_mode(&msg.e2_beta, &mut writer, compress)?;
275        }
276
277        // Serialize second messages
278        for msg in &self.second_messages {
279            CanonicalSerialize::serialize_with_mode(&msg.c_plus, &mut writer, compress)?;
280            CanonicalSerialize::serialize_with_mode(&msg.c_minus, &mut writer, compress)?;
281            CanonicalSerialize::serialize_with_mode(&msg.e1_plus, &mut writer, compress)?;
282            CanonicalSerialize::serialize_with_mode(&msg.e1_minus, &mut writer, compress)?;
283            CanonicalSerialize::serialize_with_mode(&msg.e2_plus, &mut writer, compress)?;
284            CanonicalSerialize::serialize_with_mode(&msg.e2_minus, &mut writer, compress)?;
285        }
286
287        // Serialize final message
288        CanonicalSerialize::serialize_with_mode(&self.final_message.e1, &mut writer, compress)?;
289        CanonicalSerialize::serialize_with_mode(&self.final_message.e2, &mut writer, compress)?;
290
291        // Serialize nu and sigma
292        CanonicalSerialize::serialize_with_mode(&(self.nu as u32), &mut writer, compress)?;
293        CanonicalSerialize::serialize_with_mode(&(self.sigma as u32), &mut writer, compress)?;
294
295        Ok(())
296    }
297
298    fn serialized_size(&self, compress: ArkCompress) -> usize {
299        let mut size = 0;
300
301        // VMV message
302        size += CanonicalSerialize::serialized_size(&self.vmv_message.c, compress);
303        size += CanonicalSerialize::serialized_size(&self.vmv_message.d2, compress);
304        size += CanonicalSerialize::serialized_size(&self.vmv_message.e1, compress);
305
306        // Number of rounds
307        size += 4; // u32
308
309        // First messages
310        for msg in &self.first_messages {
311            size += CanonicalSerialize::serialized_size(&msg.d1_left, compress);
312            size += CanonicalSerialize::serialized_size(&msg.d1_right, compress);
313            size += CanonicalSerialize::serialized_size(&msg.d2_left, compress);
314            size += CanonicalSerialize::serialized_size(&msg.d2_right, compress);
315            size += CanonicalSerialize::serialized_size(&msg.e1_beta, compress);
316            size += CanonicalSerialize::serialized_size(&msg.e2_beta, compress);
317        }
318
319        // Second messages
320        for msg in &self.second_messages {
321            size += CanonicalSerialize::serialized_size(&msg.c_plus, compress);
322            size += CanonicalSerialize::serialized_size(&msg.c_minus, compress);
323            size += CanonicalSerialize::serialized_size(&msg.e1_plus, compress);
324            size += CanonicalSerialize::serialized_size(&msg.e1_minus, compress);
325            size += CanonicalSerialize::serialized_size(&msg.e2_plus, compress);
326            size += CanonicalSerialize::serialized_size(&msg.e2_minus, compress);
327        }
328
329        // Final message
330        size += CanonicalSerialize::serialized_size(&self.final_message.e1, compress);
331        size += CanonicalSerialize::serialized_size(&self.final_message.e2, compress);
332
333        // nu and sigma
334        size += 8; // 2 * u32
335
336        size
337    }
338}
339
340impl CanonicalDeserialize for ArkDoryProof {
341    fn deserialize_with_mode<R: Read>(
342        mut reader: R,
343        compress: ArkCompress,
344        validate: ArkValidate,
345    ) -> Result<Self, ArkSerializationError> {
346        // Deserialize VMV message
347        let c = CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
348        let d2 = CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
349        let e1 = CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
350        let vmv_message = VMVMessage { c, d2, e1 };
351
352        // Deserialize number of rounds
353        let num_rounds =
354            <u32 as CanonicalDeserialize>::deserialize_with_mode(&mut reader, compress, validate)?
355                as usize;
356
357        // Deserialize first messages
358        let mut first_messages = Vec::with_capacity(num_rounds);
359        for _ in 0..num_rounds {
360            let d1_left =
361                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
362            let d1_right =
363                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
364            let d2_left =
365                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
366            let d2_right =
367                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
368            let e1_beta =
369                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
370            let e2_beta =
371                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
372            first_messages.push(FirstReduceMessage {
373                d1_left,
374                d1_right,
375                d2_left,
376                d2_right,
377                e1_beta,
378                e2_beta,
379            });
380        }
381
382        // Deserialize second messages
383        let mut second_messages = Vec::with_capacity(num_rounds);
384        for _ in 0..num_rounds {
385            let c_plus =
386                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
387            let c_minus =
388                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
389            let e1_plus =
390                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
391            let e1_minus =
392                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
393            let e2_plus =
394                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
395            let e2_minus =
396                CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
397            second_messages.push(SecondReduceMessage {
398                c_plus,
399                c_minus,
400                e1_plus,
401                e1_minus,
402                e2_plus,
403                e2_minus,
404            });
405        }
406
407        // Deserialize final message
408        let e1 = CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
409        let e2 = CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
410        let final_message = ScalarProductMessage { e1, e2 };
411
412        // Deserialize nu and sigma
413        let nu =
414            <u32 as CanonicalDeserialize>::deserialize_with_mode(&mut reader, compress, validate)?
415                as usize;
416        let sigma =
417            <u32 as CanonicalDeserialize>::deserialize_with_mode(&mut reader, compress, validate)?
418                as usize;
419
420        Ok(ArkDoryProof {
421            vmv_message,
422            first_messages,
423            second_messages,
424            final_message,
425            nu,
426            sigma,
427        })
428    }
429}
430
431// Setup wrapper types (declared in ark_setup.rs, serialization impls here)
432use super::{ArkworksProverSetup, ArkworksVerifierSetup};
433
434impl ArkValid for ArkworksProverSetup {
435    fn check(&self) -> Result<(), ArkSerializationError> {
436        Ok(())
437    }
438}
439
440impl CanonicalSerialize for ArkworksProverSetup {
441    fn serialize_with_mode<W: Write>(
442        &self,
443        mut writer: W,
444        compress: ArkCompress,
445    ) -> Result<(), ArkSerializationError> {
446        let dory_compress = match compress {
447            ArkCompress::Yes => Compress::Yes,
448            ArkCompress::No => Compress::No,
449        };
450
451        DorySerialize::serialize_with_mode(&self.0, &mut writer, dory_compress)
452            .map_err(|_| ArkSerializationError::InvalidData)
453    }
454
455    fn serialized_size(&self, compress: ArkCompress) -> usize {
456        let dory_compress = match compress {
457            ArkCompress::Yes => Compress::Yes,
458            ArkCompress::No => Compress::No,
459        };
460        DorySerialize::serialized_size(&self.0, dory_compress)
461    }
462}
463
464impl CanonicalDeserialize for ArkworksProverSetup {
465    fn deserialize_with_mode<R: Read>(
466        mut reader: R,
467        compress: ArkCompress,
468        validate: ArkValidate,
469    ) -> Result<Self, ArkSerializationError> {
470        let dory_compress = match compress {
471            ArkCompress::Yes => Compress::Yes,
472            ArkCompress::No => Compress::No,
473        };
474
475        let dory_validate = match validate {
476            ArkValidate::Yes => Validate::Yes,
477            ArkValidate::No => Validate::No,
478        };
479
480        let setup =
481            ProverSetup::<BN254>::deserialize_with_mode(&mut reader, dory_compress, dory_validate)
482                .map_err(|_| ArkSerializationError::InvalidData)?;
483
484        Ok(Self(setup))
485    }
486}
487
488impl ArkValid for ArkworksVerifierSetup {
489    fn check(&self) -> Result<(), ArkSerializationError> {
490        Ok(())
491    }
492}
493
494impl CanonicalSerialize for ArkworksVerifierSetup {
495    fn serialize_with_mode<W: Write>(
496        &self,
497        mut writer: W,
498        compress: ArkCompress,
499    ) -> Result<(), ArkSerializationError> {
500        let dory_compress = match compress {
501            ArkCompress::Yes => Compress::Yes,
502            ArkCompress::No => Compress::No,
503        };
504
505        DorySerialize::serialize_with_mode(&self.0, &mut writer, dory_compress)
506            .map_err(|_| ArkSerializationError::InvalidData)
507    }
508
509    fn serialized_size(&self, compress: ArkCompress) -> usize {
510        let dory_compress = match compress {
511            ArkCompress::Yes => Compress::Yes,
512            ArkCompress::No => Compress::No,
513        };
514        DorySerialize::serialized_size(&self.0, dory_compress)
515    }
516}
517
518impl CanonicalDeserialize for ArkworksVerifierSetup {
519    fn deserialize_with_mode<R: Read>(
520        mut reader: R,
521        compress: ArkCompress,
522        validate: ArkValidate,
523    ) -> Result<Self, ArkSerializationError> {
524        let dory_compress = match compress {
525            ArkCompress::Yes => Compress::Yes,
526            ArkCompress::No => Compress::No,
527        };
528
529        let dory_validate = match validate {
530            ArkValidate::Yes => Validate::Yes,
531            ArkValidate::No => Validate::No,
532        };
533
534        let setup = VerifierSetup::<BN254>::deserialize_with_mode(
535            &mut reader,
536            dory_compress,
537            dory_validate,
538        )
539        .map_err(|_| ArkSerializationError::InvalidData)?;
540
541        Ok(Self(setup))
542    }
543}
dory_pcs/backends/arkworks/ark_serde.rs

dory_pcs/backends/arkworks/
ark_serde.rs
