cml_multi_era/byron/mpc/
serialization.rs

1// This file was code-generated using an experimental CDDL to rust tool:
2// https://github.com/dcSpark/cddl-codegen
3
4use super::*;
5use cbor_event;
6use cbor_event::de::Deserializer;
7use cbor_event::se::Serializer;
8use cml_core::error::*;
9use cml_core::serialization::*;
10use cml_crypto::RawBytesEncoding;
11use std::io::{BufRead, Seek, SeekFrom, Write};
12
13impl cbor_event::se::Serialize for Ssc {
14    fn serialize<'se, W: Write>(
15        &self,
16        serializer: &'se mut Serializer<W>,
17    ) -> cbor_event::Result<&'se mut Serializer<W>> {
18        match self {
19            Ssc::SscCommitmentsPayload(ssc_commitments_payload) => {
20                ssc_commitments_payload.serialize(serializer)
21            }
22            Ssc::SscOpeningsPayload(ssc_openings_payload) => {
23                ssc_openings_payload.serialize(serializer)
24            }
25            Ssc::SscSharesPayload(ssc_shares_payload) => ssc_shares_payload.serialize(serializer),
26            Ssc::SscCertificatesPayload(ssc_certificates_payload) => {
27                ssc_certificates_payload.serialize(serializer)
28            }
29        }
30    }
31}
32
33impl Deserialize for Ssc {
34    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
35        (|| -> Result<_, DeserializeError> {
36            let initial_position = raw.as_mut_ref().stream_position().unwrap();
37            let mut errs = Vec::new();
38            let deser_variant: Result<_, DeserializeError> =
39                SscCommitmentsPayload::deserialize(raw);
40            match deser_variant {
41                Ok(ssc_commitments_payload) => {
42                    return Ok(Self::SscCommitmentsPayload(ssc_commitments_payload))
43                }
44                Err(e) => {
45                    errs.push(e.annotate("SscCommitmentsPayload"));
46                    raw.as_mut_ref()
47                        .seek(SeekFrom::Start(initial_position))
48                        .unwrap();
49                }
50            };
51            let deser_variant: Result<_, DeserializeError> = SscOpeningsPayload::deserialize(raw);
52            match deser_variant {
53                Ok(ssc_openings_payload) => {
54                    return Ok(Self::SscOpeningsPayload(ssc_openings_payload))
55                }
56                Err(e) => {
57                    errs.push(e.annotate("SscOpeningsPayload"));
58                    raw.as_mut_ref()
59                        .seek(SeekFrom::Start(initial_position))
60                        .unwrap();
61                }
62            };
63            let deser_variant: Result<_, DeserializeError> = SscSharesPayload::deserialize(raw);
64            match deser_variant {
65                Ok(ssc_shares_payload) => return Ok(Self::SscSharesPayload(ssc_shares_payload)),
66                Err(e) => {
67                    errs.push(e.annotate("SscSharesPayload"));
68                    raw.as_mut_ref()
69                        .seek(SeekFrom::Start(initial_position))
70                        .unwrap();
71                }
72            };
73            let deser_variant: Result<_, DeserializeError> =
74                SscCertificatesPayload::deserialize(raw);
75            match deser_variant {
76                Ok(ssc_certificates_payload) => {
77                    return Ok(Self::SscCertificatesPayload(ssc_certificates_payload))
78                }
79                Err(e) => {
80                    errs.push(e.annotate("SscCertificatesPayload"));
81                    raw.as_mut_ref()
82                        .seek(SeekFrom::Start(initial_position))
83                        .unwrap();
84                }
85            };
86            Err(DeserializeError::new(
87                "Ssc",
88                DeserializeFailure::NoVariantMatchedWithCauses(errs),
89            ))
90        })()
91        .map_err(|e| e.annotate("Ssc"))
92    }
93}
94
95impl cbor_event::se::Serialize for SscCert {
96    fn serialize<'se, W: Write>(
97        &self,
98        serializer: &'se mut Serializer<W>,
99    ) -> cbor_event::Result<&'se mut Serializer<W>> {
100        serializer.write_array(cbor_event::Len::Len(4))?;
101        serializer.write_bytes(&self.vss_pub_key)?;
102        serializer.write_unsigned_integer(self.epoch_id)?;
103        serializer.write_bytes(&self.byron_pub_key)?;
104        serializer.write_bytes(&self.byron_signature)?;
105        Ok(serializer)
106    }
107}
108
109impl Deserialize for SscCert {
110    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
111        let len = raw.array()?;
112        let mut read_len = CBORReadLen::from(len);
113        read_len.read_elems(4)?;
114        read_len.finish()?;
115        (|| -> Result<_, DeserializeError> {
116            let vss_pub_key = Ok(raw.bytes()? as Vec<u8>)
117                .map_err(|e: DeserializeError| e.annotate("vss_pub_key"))?;
118            let epoch_id = Ok(raw.unsigned_integer()?)
119                .map_err(|e: DeserializeError| e.annotate("epoch_id"))?;
120            let byron_pub_key = Ok(raw.bytes()? as Vec<u8>)
121                .map_err(|e: DeserializeError| e.annotate("byron_pub_key"))?;
122            let byron_signature = Ok(raw.bytes()? as Vec<u8>)
123                .map_err(|e: DeserializeError| e.annotate("byron_signature"))?;
124            match len {
125                cbor_event::Len::Len(_) => (),
126                cbor_event::Len::Indefinite => match raw.special()? {
127                    cbor_event::Special::Break => (),
128                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
129                },
130            }
131            Ok(SscCert {
132                vss_pub_key,
133                epoch_id,
134                byron_pub_key,
135                byron_signature,
136            })
137        })()
138        .map_err(|e| e.annotate("SscCert"))
139    }
140}
141
142impl cbor_event::se::Serialize for SscCertificatesPayload {
143    fn serialize<'se, W: Write>(
144        &self,
145        serializer: &'se mut Serializer<W>,
146    ) -> cbor_event::Result<&'se mut Serializer<W>> {
147        serializer.write_array(cbor_event::Len::Len(2))?;
148        serializer.write_unsigned_integer(3u64)?;
149        serializer.write_tag(258u64)?;
150        serializer.write_array(cbor_event::Len::Len(self.ssc_certs.len() as u64))?;
151        for element in self.ssc_certs.iter() {
152            element.serialize(serializer)?;
153        }
154        Ok(serializer)
155    }
156}
157
158impl Deserialize for SscCertificatesPayload {
159    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
160        let len = raw.array()?;
161        let mut read_len = CBORReadLen::from(len);
162        read_len.read_elems(2)?;
163        read_len.finish()?;
164        (|| -> Result<_, DeserializeError> {
165            (|| -> Result<_, DeserializeError> {
166                let index_0_value = raw.unsigned_integer()?;
167                if index_0_value != 3 {
168                    return Err(DeserializeFailure::FixedValueMismatch {
169                        found: Key::Uint(index_0_value),
170                        expected: Key::Uint(3),
171                    }
172                    .into());
173                }
174                Ok(())
175            })()
176            .map_err(|e| e.annotate("index_0"))?;
177            let ssc_certs = (|| -> Result<_, DeserializeError> {
178                match raw.tag()? {
179                    258 => {
180                        let mut ssc_certs_arr = Vec::new();
181                        let len = raw.array()?;
182                        while match len {
183                            cbor_event::Len::Len(n) => (ssc_certs_arr.len() as u64) < n,
184                            cbor_event::Len::Indefinite => true,
185                        } {
186                            if raw.cbor_type()? == cbor_event::Type::Special {
187                                assert_eq!(raw.special()?, cbor_event::Special::Break);
188                                break;
189                            }
190                            ssc_certs_arr.push(SscCert::deserialize(raw)?);
191                        }
192                        Ok(ssc_certs_arr)
193                    }
194                    tag => Err(DeserializeFailure::TagMismatch {
195                        found: tag,
196                        expected: 258,
197                    }
198                    .into()),
199                }
200            })()
201            .map_err(|e| e.annotate("ssc_certs"))?;
202            match len {
203                cbor_event::Len::Len(_) => (),
204                cbor_event::Len::Indefinite => match raw.special()? {
205                    cbor_event::Special::Break => (),
206                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
207                },
208            }
209            Ok(SscCertificatesPayload { ssc_certs })
210        })()
211        .map_err(|e| e.annotate("SscCertificatesPayload"))
212    }
213}
214
215impl cbor_event::se::Serialize for SscCertificatesProof {
216    fn serialize<'se, W: Write>(
217        &self,
218        serializer: &'se mut Serializer<W>,
219    ) -> cbor_event::Result<&'se mut Serializer<W>> {
220        serializer.write_array(cbor_event::Len::Len(2))?;
221        serializer.write_unsigned_integer(3u64)?;
222        serializer.write_bytes(self.blake2b256.to_raw_bytes())?;
223        Ok(serializer)
224    }
225}
226
227impl Deserialize for SscCertificatesProof {
228    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
229        let len = raw.array()?;
230        let mut read_len = CBORReadLen::from(len);
231        read_len.read_elems(2)?;
232        read_len.finish()?;
233        (|| -> Result<_, DeserializeError> {
234            (|| -> Result<_, DeserializeError> {
235                let index_0_value = raw.unsigned_integer()?;
236                if index_0_value != 3 {
237                    return Err(DeserializeFailure::FixedValueMismatch {
238                        found: Key::Uint(index_0_value),
239                        expected: Key::Uint(3),
240                    }
241                    .into());
242                }
243                Ok(())
244            })()
245            .map_err(|e| e.annotate("index_0"))?;
246            let blake2b256 = raw
247                .bytes()
248                .map_err(Into::<DeserializeError>::into)
249                .and_then(|bytes| {
250                    Blake2b256::from_raw_bytes(&bytes)
251                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
252                })
253                .map_err(|e: DeserializeError| e.annotate("blake2b256"))?;
254            match len {
255                cbor_event::Len::Len(_) => (),
256                cbor_event::Len::Indefinite => match raw.special()? {
257                    cbor_event::Special::Break => (),
258                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
259                },
260            }
261            Ok(SscCertificatesProof { blake2b256 })
262        })()
263        .map_err(|e| e.annotate("SscCertificatesProof"))
264    }
265}
266
267impl cbor_event::se::Serialize for SscCommitment {
268    fn serialize<'se, W: Write>(
269        &self,
270        serializer: &'se mut Serializer<W>,
271    ) -> cbor_event::Result<&'se mut Serializer<W>> {
272        serializer.write_array(cbor_event::Len::Len(2))?;
273        serializer.write_map(cbor_event::Len::Len(self.vss_shares.len() as u64))?;
274        for (key, value) in self.vss_shares.iter() {
275            serializer.write_bytes(key)?;
276            value.serialize(serializer)?;
277        }
278        self.vss_proof.serialize(serializer)?;
279        Ok(serializer)
280    }
281}
282
283impl Deserialize for SscCommitment {
284    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
285        let len = raw.array()?;
286        let mut read_len = CBORReadLen::from(len);
287        read_len.read_elems(2)?;
288        read_len.finish()?;
289        (|| -> Result<_, DeserializeError> {
290            let vss_shares = (|| -> Result<_, DeserializeError> {
291                let mut vss_shares_table = BTreeMap::new();
292                let vss_shares_len = raw.map()?;
293                while match vss_shares_len {
294                    cbor_event::Len::Len(n) => (vss_shares_table.len() as u64) < n,
295                    cbor_event::Len::Indefinite => true,
296                } {
297                    if raw.cbor_type()? == cbor_event::Type::Special {
298                        assert_eq!(raw.special()?, cbor_event::Special::Break);
299                        break;
300                    }
301                    let vss_shares_key = raw.bytes()? as Vec<u8>;
302                    let vss_shares_value = VssEncryptedShare::deserialize(raw)?;
303                    if vss_shares_table
304                        .insert(vss_shares_key.clone(), vss_shares_value)
305                        .is_some()
306                    {
307                        return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
308                            "some complicated/unsupported type",
309                        )))
310                        .into());
311                    }
312                }
313                Ok(vss_shares_table)
314            })()
315            .map_err(|e| e.annotate("vss_shares"))?;
316            let vss_proof = VssProof::deserialize(raw)
317                .map_err(|e: DeserializeError| e.annotate("vss_proof"))?;
318            match len {
319                cbor_event::Len::Len(_) => (),
320                cbor_event::Len::Indefinite => match raw.special()? {
321                    cbor_event::Special::Break => (),
322                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
323                },
324            }
325            Ok(SscCommitment {
326                vss_shares,
327                vss_proof,
328            })
329        })()
330        .map_err(|e| e.annotate("SscCommitment"))
331    }
332}
333
334impl cbor_event::se::Serialize for SscCommitmentsPayload {
335    fn serialize<'se, W: Write>(
336        &self,
337        serializer: &'se mut Serializer<W>,
338    ) -> cbor_event::Result<&'se mut Serializer<W>> {
339        serializer.write_array(cbor_event::Len::Len(3))?;
340        serializer.write_unsigned_integer(0u64)?;
341        serializer.write_tag(258u64)?;
342        serializer.write_array(cbor_event::Len::Len(
343            self.ssc_signed_commitments.len() as u64
344        ))?;
345        for element in self.ssc_signed_commitments.iter() {
346            element.serialize(serializer)?;
347        }
348        serializer.write_tag(258u64)?;
349        serializer.write_array(cbor_event::Len::Len(self.ssc_certs.len() as u64))?;
350        for element in self.ssc_certs.iter() {
351            element.serialize(serializer)?;
352        }
353        Ok(serializer)
354    }
355}
356
357impl Deserialize for SscCommitmentsPayload {
358    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
359        let len = raw.array()?;
360        let mut read_len = CBORReadLen::from(len);
361        read_len.read_elems(3)?;
362        read_len.finish()?;
363        (|| -> Result<_, DeserializeError> {
364            (|| -> Result<_, DeserializeError> {
365                let index_0_value = raw.unsigned_integer()?;
366                if index_0_value != 0 {
367                    return Err(DeserializeFailure::FixedValueMismatch {
368                        found: Key::Uint(index_0_value),
369                        expected: Key::Uint(0),
370                    }
371                    .into());
372                }
373                Ok(())
374            })()
375            .map_err(|e| e.annotate("index_0"))?;
376            let ssc_signed_commitments = (|| -> Result<_, DeserializeError> {
377                match raw.tag()? {
378                    258 => {
379                        let mut ssc_signed_commitments_arr = Vec::new();
380                        let len = raw.array()?;
381                        while match len {
382                            cbor_event::Len::Len(n) => {
383                                (ssc_signed_commitments_arr.len() as u64) < n
384                            }
385                            cbor_event::Len::Indefinite => true,
386                        } {
387                            if raw.cbor_type()? == cbor_event::Type::Special {
388                                assert_eq!(raw.special()?, cbor_event::Special::Break);
389                                break;
390                            }
391                            ssc_signed_commitments_arr.push(SscSignedCommitment::deserialize(raw)?);
392                        }
393                        Ok(ssc_signed_commitments_arr)
394                    }
395                    tag => Err(DeserializeFailure::TagMismatch {
396                        found: tag,
397                        expected: 258,
398                    }
399                    .into()),
400                }
401            })()
402            .map_err(|e| e.annotate("ssc_signed_commitments"))?;
403            let ssc_certs = (|| -> Result<_, DeserializeError> {
404                match raw.tag()? {
405                    258 => {
406                        let mut ssc_certs_arr = Vec::new();
407                        let len = raw.array()?;
408                        while match len {
409                            cbor_event::Len::Len(n) => (ssc_certs_arr.len() as u64) < n,
410                            cbor_event::Len::Indefinite => true,
411                        } {
412                            if raw.cbor_type()? == cbor_event::Type::Special {
413                                assert_eq!(raw.special()?, cbor_event::Special::Break);
414                                break;
415                            }
416                            ssc_certs_arr.push(SscCert::deserialize(raw)?);
417                        }
418                        Ok(ssc_certs_arr)
419                    }
420                    tag => Err(DeserializeFailure::TagMismatch {
421                        found: tag,
422                        expected: 258,
423                    }
424                    .into()),
425                }
426            })()
427            .map_err(|e| e.annotate("ssc_certs"))?;
428            match len {
429                cbor_event::Len::Len(_) => (),
430                cbor_event::Len::Indefinite => match raw.special()? {
431                    cbor_event::Special::Break => (),
432                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
433                },
434            }
435            Ok(SscCommitmentsPayload {
436                ssc_signed_commitments,
437                ssc_certs,
438            })
439        })()
440        .map_err(|e| e.annotate("SscCommitmentsPayload"))
441    }
442}
443
444impl cbor_event::se::Serialize for SscCommitmentsProof {
445    fn serialize<'se, W: Write>(
446        &self,
447        serializer: &'se mut Serializer<W>,
448    ) -> cbor_event::Result<&'se mut Serializer<W>> {
449        serializer.write_array(cbor_event::Len::Len(3))?;
450        serializer.write_unsigned_integer(0u64)?;
451        serializer.write_bytes(self.blake2b256.to_raw_bytes())?;
452        serializer.write_bytes(self.blake2b2562.to_raw_bytes())?;
453        Ok(serializer)
454    }
455}
456
457impl Deserialize for SscCommitmentsProof {
458    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
459        let len = raw.array()?;
460        let mut read_len = CBORReadLen::from(len);
461        read_len.read_elems(3)?;
462        read_len.finish()?;
463        (|| -> Result<_, DeserializeError> {
464            (|| -> Result<_, DeserializeError> {
465                let index_0_value = raw.unsigned_integer()?;
466                if index_0_value != 0 {
467                    return Err(DeserializeFailure::FixedValueMismatch {
468                        found: Key::Uint(index_0_value),
469                        expected: Key::Uint(0),
470                    }
471                    .into());
472                }
473                Ok(())
474            })()
475            .map_err(|e| e.annotate("index_0"))?;
476            let blake2b256 = raw
477                .bytes()
478                .map_err(Into::<DeserializeError>::into)
479                .and_then(|bytes| {
480                    Blake2b256::from_raw_bytes(&bytes)
481                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
482                })
483                .map_err(|e: DeserializeError| e.annotate("blake2b256"))?;
484            let blake2b2562 = raw
485                .bytes()
486                .map_err(Into::<DeserializeError>::into)
487                .and_then(|bytes| {
488                    Blake2b256::from_raw_bytes(&bytes)
489                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
490                })
491                .map_err(|e: DeserializeError| e.annotate("blake2b2562"))?;
492            match len {
493                cbor_event::Len::Len(_) => (),
494                cbor_event::Len::Indefinite => match raw.special()? {
495                    cbor_event::Special::Break => (),
496                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
497                },
498            }
499            Ok(SscCommitmentsProof {
500                blake2b256,
501                blake2b2562,
502            })
503        })()
504        .map_err(|e| e.annotate("SscCommitmentsProof"))
505    }
506}
507
508impl cbor_event::se::Serialize for SscOpeningsPayload {
509    fn serialize<'se, W: Write>(
510        &self,
511        serializer: &'se mut Serializer<W>,
512    ) -> cbor_event::Result<&'se mut Serializer<W>> {
513        serializer.write_array(cbor_event::Len::Len(3))?;
514        serializer.write_unsigned_integer(1u64)?;
515        serializer.write_map(cbor_event::Len::Len(self.ssc_opens.len() as u64))?;
516        for (key, value) in self.ssc_opens.iter() {
517            serializer.write_bytes(key.to_raw_bytes())?;
518            serializer.write_bytes(value)?;
519        }
520        serializer.write_tag(258u64)?;
521        serializer.write_array(cbor_event::Len::Len(self.ssc_certs.len() as u64))?;
522        for element in self.ssc_certs.iter() {
523            element.serialize(serializer)?;
524        }
525        Ok(serializer)
526    }
527}
528
529impl Deserialize for SscOpeningsPayload {
530    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
531        let len = raw.array()?;
532        let mut read_len = CBORReadLen::from(len);
533        read_len.read_elems(3)?;
534        read_len.finish()?;
535        (|| -> Result<_, DeserializeError> {
536            (|| -> Result<_, DeserializeError> {
537                let index_0_value = raw.unsigned_integer()?;
538                if index_0_value != 1 {
539                    return Err(DeserializeFailure::FixedValueMismatch {
540                        found: Key::Uint(index_0_value),
541                        expected: Key::Uint(1),
542                    }
543                    .into());
544                }
545                Ok(())
546            })()
547            .map_err(|e| e.annotate("index_0"))?;
548            let ssc_opens = (|| -> Result<_, DeserializeError> {
549                let mut ssc_opens_table = BTreeMap::new();
550                let ssc_opens_len = raw.map()?;
551                while match ssc_opens_len {
552                    cbor_event::Len::Len(n) => (ssc_opens_table.len() as u64) < n,
553                    cbor_event::Len::Indefinite => true,
554                } {
555                    if raw.cbor_type()? == cbor_event::Type::Special {
556                        assert_eq!(raw.special()?, cbor_event::Special::Break);
557                        break;
558                    }
559                    let ssc_opens_key = raw
560                        .bytes()
561                        .map_err(Into::<DeserializeError>::into)
562                        .and_then(|bytes| {
563                            StakeholderId::from_raw_bytes(&bytes).map_err(|e| {
564                                DeserializeFailure::InvalidStructure(Box::new(e)).into()
565                            })
566                        })?;
567                    let ssc_opens_value = raw.bytes()? as Vec<u8>;
568                    if ssc_opens_table
569                        .insert(ssc_opens_key, ssc_opens_value)
570                        .is_some()
571                    {
572                        return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
573                            "some complicated/unsupported type",
574                        )))
575                        .into());
576                    }
577                }
578                Ok(ssc_opens_table)
579            })()
580            .map_err(|e| e.annotate("ssc_opens"))?;
581            let ssc_certs = (|| -> Result<_, DeserializeError> {
582                match raw.tag()? {
583                    258 => {
584                        let mut ssc_certs_arr = Vec::new();
585                        let len = raw.array()?;
586                        while match len {
587                            cbor_event::Len::Len(n) => (ssc_certs_arr.len() as u64) < n,
588                            cbor_event::Len::Indefinite => true,
589                        } {
590                            if raw.cbor_type()? == cbor_event::Type::Special {
591                                assert_eq!(raw.special()?, cbor_event::Special::Break);
592                                break;
593                            }
594                            ssc_certs_arr.push(SscCert::deserialize(raw)?);
595                        }
596                        Ok(ssc_certs_arr)
597                    }
598                    tag => Err(DeserializeFailure::TagMismatch {
599                        found: tag,
600                        expected: 258,
601                    }
602                    .into()),
603                }
604            })()
605            .map_err(|e| e.annotate("ssc_certs"))?;
606            match len {
607                cbor_event::Len::Len(_) => (),
608                cbor_event::Len::Indefinite => match raw.special()? {
609                    cbor_event::Special::Break => (),
610                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
611                },
612            }
613            Ok(SscOpeningsPayload {
614                ssc_opens,
615                ssc_certs,
616            })
617        })()
618        .map_err(|e| e.annotate("SscOpeningsPayload"))
619    }
620}
621
622impl cbor_event::se::Serialize for SscOpeningsProof {
623    fn serialize<'se, W: Write>(
624        &self,
625        serializer: &'se mut Serializer<W>,
626    ) -> cbor_event::Result<&'se mut Serializer<W>> {
627        serializer.write_array(cbor_event::Len::Len(3))?;
628        serializer.write_unsigned_integer(1u64)?;
629        serializer.write_bytes(self.blake2b256.to_raw_bytes())?;
630        serializer.write_bytes(self.blake2b2562.to_raw_bytes())?;
631        Ok(serializer)
632    }
633}
634
635impl Deserialize for SscOpeningsProof {
636    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
637        let len = raw.array()?;
638        let mut read_len = CBORReadLen::from(len);
639        read_len.read_elems(3)?;
640        read_len.finish()?;
641        (|| -> Result<_, DeserializeError> {
642            (|| -> Result<_, DeserializeError> {
643                let index_0_value = raw.unsigned_integer()?;
644                if index_0_value != 1 {
645                    return Err(DeserializeFailure::FixedValueMismatch {
646                        found: Key::Uint(index_0_value),
647                        expected: Key::Uint(1),
648                    }
649                    .into());
650                }
651                Ok(())
652            })()
653            .map_err(|e| e.annotate("index_0"))?;
654            let blake2b256 = raw
655                .bytes()
656                .map_err(Into::<DeserializeError>::into)
657                .and_then(|bytes| {
658                    Blake2b256::from_raw_bytes(&bytes)
659                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
660                })
661                .map_err(|e: DeserializeError| e.annotate("blake2b256"))?;
662            let blake2b2562 = raw
663                .bytes()
664                .map_err(Into::<DeserializeError>::into)
665                .and_then(|bytes| {
666                    Blake2b256::from_raw_bytes(&bytes)
667                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
668                })
669                .map_err(|e: DeserializeError| e.annotate("blake2b2562"))?;
670            match len {
671                cbor_event::Len::Len(_) => (),
672                cbor_event::Len::Indefinite => match raw.special()? {
673                    cbor_event::Special::Break => (),
674                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
675                },
676            }
677            Ok(SscOpeningsProof {
678                blake2b256,
679                blake2b2562,
680            })
681        })()
682        .map_err(|e| e.annotate("SscOpeningsProof"))
683    }
684}
685
686impl cbor_event::se::Serialize for SscProof {
687    fn serialize<'se, W: Write>(
688        &self,
689        serializer: &'se mut Serializer<W>,
690    ) -> cbor_event::Result<&'se mut Serializer<W>> {
691        match self {
692            SscProof::SscCommitmentsProof(ssc_commitments_proof) => {
693                ssc_commitments_proof.serialize(serializer)
694            }
695            SscProof::SscOpeningsProof(ssc_openings_proof) => {
696                ssc_openings_proof.serialize(serializer)
697            }
698            SscProof::SscSharesProof(ssc_shares_proof) => ssc_shares_proof.serialize(serializer),
699            SscProof::SscCertificatesProof(ssc_certificates_proof) => {
700                ssc_certificates_proof.serialize(serializer)
701            }
702        }
703    }
704}
705
706impl Deserialize for SscProof {
707    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
708        (|| -> Result<_, DeserializeError> {
709            let initial_position = raw.as_mut_ref().stream_position().unwrap();
710            let mut errs = Vec::new();
711            let deser_variant: Result<_, DeserializeError> = SscCommitmentsProof::deserialize(raw);
712            match deser_variant {
713                Ok(ssc_commitments_proof) => {
714                    return Ok(Self::SscCommitmentsProof(ssc_commitments_proof))
715                }
716                Err(e) => {
717                    errs.push(e.annotate("SscCommitmentsProof"));
718                    raw.as_mut_ref()
719                        .seek(SeekFrom::Start(initial_position))
720                        .unwrap();
721                }
722            };
723            let deser_variant: Result<_, DeserializeError> = SscOpeningsProof::deserialize(raw);
724            match deser_variant {
725                Ok(ssc_openings_proof) => return Ok(Self::SscOpeningsProof(ssc_openings_proof)),
726                Err(e) => {
727                    errs.push(e.annotate("SscOpeningsProof"));
728                    raw.as_mut_ref()
729                        .seek(SeekFrom::Start(initial_position))
730                        .unwrap();
731                }
732            };
733            let deser_variant: Result<_, DeserializeError> = SscSharesProof::deserialize(raw);
734            match deser_variant {
735                Ok(ssc_shares_proof) => return Ok(Self::SscSharesProof(ssc_shares_proof)),
736                Err(e) => {
737                    errs.push(e.annotate("SscSharesProof"));
738                    raw.as_mut_ref()
739                        .seek(SeekFrom::Start(initial_position))
740                        .unwrap();
741                }
742            };
743            let deser_variant: Result<_, DeserializeError> = SscCertificatesProof::deserialize(raw);
744            match deser_variant {
745                Ok(ssc_certificates_proof) => {
746                    return Ok(Self::SscCertificatesProof(ssc_certificates_proof))
747                }
748                Err(e) => {
749                    errs.push(e.annotate("SscCertificatesProof"));
750                    raw.as_mut_ref()
751                        .seek(SeekFrom::Start(initial_position))
752                        .unwrap();
753                }
754            };
755            Err(DeserializeError::new(
756                "SscProof",
757                DeserializeFailure::NoVariantMatchedWithCauses(errs),
758            ))
759        })()
760        .map_err(|e| e.annotate("SscProof"))
761    }
762}
763
764impl cbor_event::se::Serialize for SscSharesPayload {
765    fn serialize<'se, W: Write>(
766        &self,
767        serializer: &'se mut Serializer<W>,
768    ) -> cbor_event::Result<&'se mut Serializer<W>> {
769        serializer.write_array(cbor_event::Len::Len(3))?;
770        serializer.write_unsigned_integer(2u64)?;
771        serializer.write_map(cbor_event::Len::Len(self.ssc_shares.len() as u64))?;
772        for (key, value) in self.ssc_shares.iter() {
773            serializer.write_bytes(key.to_raw_bytes())?;
774            serializer.write_map(cbor_event::Len::Len(value.len() as u64))?;
775            for (key, value) in value.iter() {
776                serializer.write_bytes(key.to_raw_bytes())?;
777                serializer.write_array(cbor_event::Len::Indefinite)?;
778                for element in value.iter() {
779                    serializer.write_bytes(element)?;
780                }
781                serializer.write_special(cbor_event::Special::Break)?;
782            }
783        }
784        serializer.write_tag(258u64)?;
785        serializer.write_array(cbor_event::Len::Len(self.ssc_certs.len() as u64))?;
786        for element in self.ssc_certs.iter() {
787            element.serialize(serializer)?;
788        }
789        Ok(serializer)
790    }
791}
792
793impl Deserialize for SscSharesPayload {
794    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
795        let len = raw.array()?;
796        let mut read_len = CBORReadLen::from(len);
797        read_len.read_elems(3)?;
798        read_len.finish()?;
799        (|| -> Result<_, DeserializeError> {
800            (|| -> Result<_, DeserializeError> {
801                let index_0_value = raw.unsigned_integer()?;
802                if index_0_value != 2 {
803                    return Err(DeserializeFailure::FixedValueMismatch {
804                        found: Key::Uint(index_0_value),
805                        expected: Key::Uint(2),
806                    }
807                    .into());
808                }
809                Ok(())
810            })()
811            .map_err(|e| e.annotate("index_0"))?;
812            let ssc_shares = (|| -> Result<_, DeserializeError> {
813                let mut ssc_shares_table = BTreeMap::new();
814                let ssc_shares_len = raw.map()?;
815                while match ssc_shares_len {
816                    cbor_event::Len::Len(n) => (ssc_shares_table.len() as u64) < n,
817                    cbor_event::Len::Indefinite => true,
818                } {
819                    if raw.cbor_type()? == cbor_event::Type::Special {
820                        assert_eq!(raw.special()?, cbor_event::Special::Break);
821                        break;
822                    }
823                    let ssc_shares_key = raw
824                        .bytes()
825                        .map_err(Into::<DeserializeError>::into)
826                        .and_then(|bytes| {
827                            AddressId::from_raw_bytes(&bytes).map_err(|e| {
828                                DeserializeFailure::InvalidStructure(Box::new(e)).into()
829                            })
830                        })?;
831                    let mut ssc_shares_value_table = BTreeMap::new();
832                    let ssc_shares_value_len = raw.map()?;
833                    while match ssc_shares_value_len {
834                        cbor_event::Len::Len(n) => (ssc_shares_value_table.len() as u64) < n,
835                        cbor_event::Len::Indefinite => true,
836                    } {
837                        if raw.cbor_type()? == cbor_event::Type::Special {
838                            assert_eq!(raw.special()?, cbor_event::Special::Break);
839                            break;
840                        }
841                        let ssc_shares_value_key = raw
842                            .bytes()
843                            .map_err(Into::<DeserializeError>::into)
844                            .and_then(|bytes| {
845                                AddressId::from_raw_bytes(&bytes).map_err(|e| {
846                                    DeserializeFailure::InvalidStructure(Box::new(e)).into()
847                                })
848                            })?;
849                        let mut ssc_shares_value_value_arr = Vec::new();
850                        let len = raw.array()?;
851                        while match len {
852                            cbor_event::Len::Len(n) => {
853                                (ssc_shares_value_value_arr.len() as u64) < n
854                            }
855                            cbor_event::Len::Indefinite => true,
856                        } {
857                            if raw.cbor_type()? == cbor_event::Type::Special {
858                                assert_eq!(raw.special()?, cbor_event::Special::Break);
859                                break;
860                            }
861                            ssc_shares_value_value_arr.push(raw.bytes()? as Vec<u8>);
862                        }
863                        let ssc_shares_value_value = ssc_shares_value_value_arr;
864                        if ssc_shares_value_table
865                            .insert(ssc_shares_value_key, ssc_shares_value_value)
866                            .is_some()
867                        {
868                            return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
869                                "some complicated/unsupported type",
870                            )))
871                            .into());
872                        }
873                    }
874                    let ssc_shares_value = ssc_shares_value_table;
875                    if ssc_shares_table
876                        .insert(ssc_shares_key, ssc_shares_value)
877                        .is_some()
878                    {
879                        return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
880                            "some complicated/unsupported type",
881                        )))
882                        .into());
883                    }
884                }
885                Ok(ssc_shares_table)
886            })()
887            .map_err(|e| e.annotate("ssc_shares"))?;
888            let ssc_certs = (|| -> Result<_, DeserializeError> {
889                match raw.tag()? {
890                    258 => {
891                        let mut ssc_certs_arr = Vec::new();
892                        let len = raw.array()?;
893                        while match len {
894                            cbor_event::Len::Len(n) => (ssc_certs_arr.len() as u64) < n,
895                            cbor_event::Len::Indefinite => true,
896                        } {
897                            if raw.cbor_type()? == cbor_event::Type::Special {
898                                assert_eq!(raw.special()?, cbor_event::Special::Break);
899                                break;
900                            }
901                            ssc_certs_arr.push(SscCert::deserialize(raw)?);
902                        }
903                        Ok(ssc_certs_arr)
904                    }
905                    tag => Err(DeserializeFailure::TagMismatch {
906                        found: tag,
907                        expected: 258,
908                    }
909                    .into()),
910                }
911            })()
912            .map_err(|e| e.annotate("ssc_certs"))?;
913            match len {
914                cbor_event::Len::Len(_) => (),
915                cbor_event::Len::Indefinite => match raw.special()? {
916                    cbor_event::Special::Break => (),
917                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
918                },
919            }
920            Ok(SscSharesPayload {
921                ssc_shares,
922                ssc_certs,
923            })
924        })()
925        .map_err(|e| e.annotate("SscSharesPayload"))
926    }
927}
928
929impl cbor_event::se::Serialize for SscSharesProof {
930    fn serialize<'se, W: Write>(
931        &self,
932        serializer: &'se mut Serializer<W>,
933    ) -> cbor_event::Result<&'se mut Serializer<W>> {
934        serializer.write_array(cbor_event::Len::Len(3))?;
935        serializer.write_unsigned_integer(2u64)?;
936        serializer.write_bytes(self.blake2b256.to_raw_bytes())?;
937        serializer.write_bytes(self.blake2b2562.to_raw_bytes())?;
938        Ok(serializer)
939    }
940}
941
942impl Deserialize for SscSharesProof {
943    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
944        let len = raw.array()?;
945        let mut read_len = CBORReadLen::from(len);
946        read_len.read_elems(3)?;
947        read_len.finish()?;
948        (|| -> Result<_, DeserializeError> {
949            (|| -> Result<_, DeserializeError> {
950                let index_0_value = raw.unsigned_integer()?;
951                if index_0_value != 2 {
952                    return Err(DeserializeFailure::FixedValueMismatch {
953                        found: Key::Uint(index_0_value),
954                        expected: Key::Uint(2),
955                    }
956                    .into());
957                }
958                Ok(())
959            })()
960            .map_err(|e| e.annotate("index_0"))?;
961            let blake2b256 = raw
962                .bytes()
963                .map_err(Into::<DeserializeError>::into)
964                .and_then(|bytes| {
965                    Blake2b256::from_raw_bytes(&bytes)
966                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
967                })
968                .map_err(|e: DeserializeError| e.annotate("blake2b256"))?;
969            let blake2b2562 = raw
970                .bytes()
971                .map_err(Into::<DeserializeError>::into)
972                .and_then(|bytes| {
973                    Blake2b256::from_raw_bytes(&bytes)
974                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
975                })
976                .map_err(|e: DeserializeError| e.annotate("blake2b2562"))?;
977            match len {
978                cbor_event::Len::Len(_) => (),
979                cbor_event::Len::Indefinite => match raw.special()? {
980                    cbor_event::Special::Break => (),
981                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
982                },
983            }
984            Ok(SscSharesProof {
985                blake2b256,
986                blake2b2562,
987            })
988        })()
989        .map_err(|e| e.annotate("SscSharesProof"))
990    }
991}
992
993impl cbor_event::se::Serialize for SscSignedCommitment {
994    fn serialize<'se, W: Write>(
995        &self,
996        serializer: &'se mut Serializer<W>,
997    ) -> cbor_event::Result<&'se mut Serializer<W>> {
998        serializer.write_array(cbor_event::Len::Len(3))?;
999        serializer.write_bytes(&self.byron_pub_key)?;
1000        self.ssc_commitment.serialize(serializer)?;
1001        serializer.write_bytes(&self.byron_signature)?;
1002        Ok(serializer)
1003    }
1004}
1005
1006impl Deserialize for SscSignedCommitment {
1007    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1008        let len = raw.array()?;
1009        let mut read_len = CBORReadLen::from(len);
1010        read_len.read_elems(3)?;
1011        read_len.finish()?;
1012        (|| -> Result<_, DeserializeError> {
1013            let byron_pub_key = Ok(raw.bytes()? as Vec<u8>)
1014                .map_err(|e: DeserializeError| e.annotate("byron_pub_key"))?;
1015            let ssc_commitment = SscCommitment::deserialize(raw)
1016                .map_err(|e: DeserializeError| e.annotate("ssc_commitment"))?;
1017            let byron_signature = Ok(raw.bytes()? as Vec<u8>)
1018                .map_err(|e: DeserializeError| e.annotate("byron_signature"))?;
1019            match len {
1020                cbor_event::Len::Len(_) => (),
1021                cbor_event::Len::Indefinite => match raw.special()? {
1022                    cbor_event::Special::Break => (),
1023                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1024                },
1025            }
1026            Ok(SscSignedCommitment {
1027                byron_pub_key,
1028                ssc_commitment,
1029                byron_signature,
1030            })
1031        })()
1032        .map_err(|e| e.annotate("SscSignedCommitment"))
1033    }
1034}
1035
1036impl cbor_event::se::Serialize for VssEncryptedShare {
1037    fn serialize<'se, W: Write>(
1038        &self,
1039        serializer: &'se mut Serializer<W>,
1040    ) -> cbor_event::Result<&'se mut Serializer<W>> {
1041        //serializer.write_array(cbor_event::Len::Len(1))?;
1042        serializer.write_array(cbor_event::Len::Indefinite)?;
1043        serializer.write_bytes(&self.index_0)?;
1044        serializer.write_special(cbor_event::Special::Break)?;
1045        Ok(serializer)
1046    }
1047}
1048
1049impl Deserialize for VssEncryptedShare {
1050    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1051        let len = raw.array()?;
1052        let mut read_len = CBORReadLen::from(len);
1053        read_len.read_elems(1)?;
1054        read_len.finish()?;
1055        (|| -> Result<_, DeserializeError> {
1056            let index_0 =
1057                Ok(raw.bytes()? as Vec<u8>).map_err(|e: DeserializeError| e.annotate("index_0"))?;
1058            match len {
1059                cbor_event::Len::Len(_) => (),
1060                cbor_event::Len::Indefinite => match raw.special()? {
1061                    cbor_event::Special::Break => (),
1062                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1063                },
1064            }
1065            Ok(VssEncryptedShare { index_0 })
1066        })()
1067        .map_err(|e| e.annotate("VssEncryptedShare"))
1068    }
1069}
1070
1071impl cbor_event::se::Serialize for VssProof {
1072    fn serialize<'se, W: Write>(
1073        &self,
1074        serializer: &'se mut Serializer<W>,
1075    ) -> cbor_event::Result<&'se mut Serializer<W>> {
1076        serializer.write_array(cbor_event::Len::Len(4))?;
1077        serializer.write_bytes(&self.extra_gen)?;
1078        serializer.write_bytes(&self.proof)?;
1079        serializer.write_bytes(&self.parallel_proofs)?;
1080        //serializer.write_array(cbor_event::Len::Len(self.bytess.len() as u64))?;
1081        serializer.write_array(cbor_event::Len::Indefinite)?;
1082        for element in self.bytess.iter() {
1083            serializer.write_bytes(element)?;
1084        }
1085        serializer.write_special(cbor_event::Special::Break)?;
1086        Ok(serializer)
1087    }
1088}
1089
1090impl Deserialize for VssProof {
1091    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1092        let len = raw.array()?;
1093        let mut read_len = CBORReadLen::from(len);
1094        read_len.read_elems(4)?;
1095        read_len.finish()?;
1096        (|| -> Result<_, DeserializeError> {
1097            let extra_gen = Ok(raw.bytes()? as Vec<u8>)
1098                .map_err(|e: DeserializeError| e.annotate("extra_gen"))?;
1099            let proof =
1100                Ok(raw.bytes()? as Vec<u8>).map_err(|e: DeserializeError| e.annotate("proof"))?;
1101            let parallel_proofs = Ok(raw.bytes()? as Vec<u8>)
1102                .map_err(|e: DeserializeError| e.annotate("parallel_proofs"))?;
1103            let bytess = (|| -> Result<_, DeserializeError> {
1104                let mut bytess_arr = Vec::new();
1105                let len = raw.array()?;
1106                while match len {
1107                    cbor_event::Len::Len(n) => (bytess_arr.len() as u64) < n,
1108                    cbor_event::Len::Indefinite => true,
1109                } {
1110                    if raw.cbor_type()? == cbor_event::Type::Special {
1111                        assert_eq!(raw.special()?, cbor_event::Special::Break);
1112                        break;
1113                    }
1114                    bytess_arr.push(raw.bytes()? as Vec<u8>);
1115                }
1116                Ok(bytess_arr)
1117            })()
1118            .map_err(|e| e.annotate("bytess"))?;
1119            match len {
1120                cbor_event::Len::Len(_) => (),
1121                cbor_event::Len::Indefinite => match raw.special()? {
1122                    cbor_event::Special::Break => (),
1123                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1124                },
1125            }
1126            Ok(VssProof {
1127                extra_gen,
1128                proof,
1129                parallel_proofs,
1130                bytess,
1131            })
1132        })()
1133        .map_err(|e| e.annotate("VssProof"))
1134    }
1135}
cml_multi_era/byron/mpc/serialization.rs

cml_multi_era/byron/mpc/
serialization.rs
