cml_chain/crypto/
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::cbor_encodings::*;
5use super::*;
6use crate::byron::AddrAttributes;
7use cbor_event::de::Deserializer;
8use cbor_event::se::Serializer;
9use cml_core::error::*;
10use cml_core::serialization::*;
11use cml_crypto::RawBytesEncoding;
12use std::io::{BufRead, Seek, SeekFrom, Write};
13
14impl Serialize for BootstrapWitness {
15    fn serialize<'se, W: Write>(
16        &self,
17        serializer: &'se mut Serializer<W>,
18        force_canonical: bool,
19    ) -> cbor_event::Result<&'se mut Serializer<W>> {
20        serializer.write_array_sz(
21            self.encodings
22                .as_ref()
23                .map(|encs| encs.len_encoding)
24                .unwrap_or_default()
25                .to_len_sz(4, force_canonical),
26        )?;
27        serializer.write_bytes_sz(
28            self.public_key.to_raw_bytes(),
29            self.encodings
30                .as_ref()
31                .map(|encs| encs.public_key_encoding.clone())
32                .unwrap_or_default()
33                .to_str_len_sz(self.public_key.to_raw_bytes().len() as u64, force_canonical),
34        )?;
35        serializer.write_bytes_sz(
36            self.signature.to_raw_bytes(),
37            self.encodings
38                .as_ref()
39                .map(|encs| encs.signature_encoding.clone())
40                .unwrap_or_default()
41                .to_str_len_sz(self.signature.to_raw_bytes().len() as u64, force_canonical),
42        )?;
43        serializer.write_bytes_sz(
44            &self.chain_code,
45            self.encodings
46                .as_ref()
47                .map(|encs| encs.chain_code_encoding.clone())
48                .unwrap_or_default()
49                .to_str_len_sz(self.chain_code.len() as u64, force_canonical),
50        )?;
51        let mut attributes_inner_se = Serializer::new_vec();
52        // Manual edit: This is from Byron, thus uses cbor_event::Serialize
53        cbor_event::Serialize::serialize(&self.attributes, &mut attributes_inner_se)?;
54        let attributes_bytes = attributes_inner_se.finalize();
55        serializer.write_bytes_sz(
56            &attributes_bytes,
57            self.encodings
58                .as_ref()
59                .map(|encs| encs.attributes_bytes_encoding.clone())
60                .unwrap_or_default()
61                .to_str_len_sz(attributes_bytes.len() as u64, force_canonical),
62        )?;
63        self.encodings
64            .as_ref()
65            .map(|encs| encs.len_encoding)
66            .unwrap_or_default()
67            .end(serializer, force_canonical)
68    }
69}
70
71impl Deserialize for BootstrapWitness {
72    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
73        let len = raw.array_sz()?;
74        let len_encoding: LenEncoding = len.into();
75        let mut read_len = CBORReadLen::new(len);
76        read_len.read_elems(4)?;
77        read_len.finish()?;
78        (|| -> Result<_, DeserializeError> {
79            let (public_key, public_key_encoding) = raw
80                .bytes_sz()
81                .map_err(Into::<DeserializeError>::into)
82                .and_then(|(bytes, enc)| {
83                    Vkey::from_raw_bytes(&bytes)
84                        .map(|bytes| (bytes, StringEncoding::from(enc)))
85                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
86                })
87                .map_err(|e: DeserializeError| e.annotate("public_key"))?;
88            let (signature, signature_encoding) = raw
89                .bytes_sz()
90                .map_err(Into::<DeserializeError>::into)
91                .and_then(|(bytes, enc)| {
92                    Ed25519Signature::from_raw_bytes(&bytes)
93                        .map(|bytes| (bytes, StringEncoding::from(enc)))
94                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
95                })
96                .map_err(|e: DeserializeError| e.annotate("signature"))?;
97            let (chain_code, chain_code_encoding) = raw
98                .bytes_sz()
99                .map_err(Into::<DeserializeError>::into)
100                .map_err(Into::<DeserializeError>::into)
101                .and_then(|(bytes, enc)| {
102                    if bytes.len() < 32 || bytes.len() > 32 {
103                        Err(DeserializeFailure::RangeCheck {
104                            found: bytes.len() as isize,
105                            min: Some(32),
106                            max: Some(32),
107                        }
108                        .into())
109                    } else {
110                        Ok((bytes, StringEncoding::from(enc)))
111                    }
112                })
113                .map_err(|e: DeserializeError| e.annotate("chain_code"))?;
114            let (attributes, attributes_bytes_encoding) = (|| -> Result<_, DeserializeError> {
115                let (attributes_bytes, attributes_bytes_encoding) = raw.bytes_sz()?;
116                let inner_de = &mut Deserializer::from(std::io::Cursor::new(attributes_bytes));
117                Ok((
118                    AddrAttributes::deserialize(inner_de)?,
119                    StringEncoding::from(attributes_bytes_encoding),
120                ))
121            })()
122            .map_err(|e| e.annotate("attributes"))?;
123            match len {
124                cbor_event::LenSz::Len(_, _) => (),
125                cbor_event::LenSz::Indefinite => match raw.special()? {
126                    cbor_event::Special::Break => (),
127                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
128                },
129            }
130            Ok(BootstrapWitness {
131                public_key,
132                signature,
133                chain_code,
134                attributes,
135                encodings: Some(BootstrapWitnessEncoding {
136                    len_encoding,
137                    public_key_encoding,
138                    signature_encoding,
139                    chain_code_encoding,
140                    attributes_bytes_encoding,
141                }),
142            })
143        })()
144        .map_err(|e| e.annotate("BootstrapWitness"))
145    }
146}
147
148impl Serialize for KESSignature {
149    fn serialize<'se, W: Write>(
150        &self,
151        serializer: &'se mut Serializer<W>,
152        force_canonical: bool,
153    ) -> cbor_event::Result<&'se mut Serializer<W>> {
154        serializer.write_bytes_sz(
155            &self.inner,
156            self.encodings
157                .as_ref()
158                .map(|encs| encs.inner_encoding.clone())
159                .unwrap_or_default()
160                .to_str_len_sz(self.inner.len() as u64, force_canonical),
161        )
162    }
163}
164
165impl Deserialize for KESSignature {
166    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
167        let (inner, inner_encoding) = raw
168            .bytes_sz()
169            .map(|(bytes, enc)| (bytes, StringEncoding::from(enc)))?;
170        if inner.len() != 448 {
171            return Err(DeserializeError::new(
172                "KESSignature",
173                DeserializeFailure::RangeCheck {
174                    found: inner.len() as isize,
175                    min: Some(448),
176                    max: Some(448),
177                },
178            ));
179        }
180        Ok(Self {
181            inner,
182            encodings: Some(KESSignatureEncoding { inner_encoding }),
183        })
184    }
185}
186
187impl Serialize for Nonce {
188    fn serialize<'se, W: Write>(
189        &self,
190        serializer: &'se mut Serializer<W>,
191        force_canonical: bool,
192    ) -> cbor_event::Result<&'se mut Serializer<W>> {
193        match self {
194            Nonce::Identity {
195                identity_encoding,
196                len_encoding,
197            } => {
198                serializer.write_array_sz(len_encoding.to_len_sz(1, force_canonical))?;
199                serializer.write_unsigned_integer_sz(
200                    0u64,
201                    fit_sz(0u64, *identity_encoding, force_canonical),
202                )?;
203                len_encoding.end(serializer, force_canonical)?;
204                Ok(serializer)
205            }
206            Nonce::Hash {
207                hash,
208                len_encoding,
209                tag_encoding,
210                hash_encoding,
211            } => {
212                serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
213                serializer.write_unsigned_integer_sz(
214                    1u64,
215                    fit_sz(1u64, *tag_encoding, force_canonical),
216                )?;
217                serializer.write_bytes_sz(
218                    hash.to_raw_bytes(),
219                    hash_encoding.to_str_len_sz(hash.to_raw_bytes().len() as u64, force_canonical),
220                )?;
221                len_encoding.end(serializer, force_canonical)?;
222                Ok(serializer)
223            }
224        }
225    }
226}
227
228impl Deserialize for Nonce {
229    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
230        (|| -> Result<_, DeserializeError> {
231            let len = raw.array_sz()?;
232            let len_encoding: LenEncoding = len.into();
233            let initial_position = raw.as_mut_ref().stream_position().unwrap();
234            let mut errs = Vec::new();
235            let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
236                let mut read_len = CBORReadLen::new(len);
237                read_len.read_elems(1)?;
238                read_len.finish()?;
239                let (identity_value, identity_encoding) = raw.unsigned_integer_sz()?;
240                if identity_value != 0 {
241                    return Err(DeserializeFailure::FixedValueMismatch {
242                        found: Key::Uint(identity_value),
243                        expected: Key::Uint(0),
244                    }
245                    .into());
246                }
247                let ret = Ok(Some(identity_encoding));
248                match len {
249                    cbor_event::LenSz::Len(_, _) => (),
250                    cbor_event::LenSz::Indefinite => match raw.special()? {
251                        cbor_event::Special::Break => (),
252                        _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
253                    },
254                }
255                ret
256            })(raw);
257            match deser_variant {
258                Ok(identity_encoding) => {
259                    return Ok(Self::Identity {
260                        identity_encoding,
261                        len_encoding,
262                    })
263                }
264                Err(e) => {
265                    errs.push(e.annotate("Identity"));
266                    raw.as_mut_ref()
267                        .seek(SeekFrom::Start(initial_position))
268                        .unwrap();
269                }
270            };
271            let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
272                let mut read_len = CBORReadLen::new(len);
273                read_len.read_elems(2)?;
274                read_len.finish()?;
275                let tag_encoding = (|| -> Result<_, DeserializeError> {
276                    let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
277                    if tag_value != 1 {
278                        return Err(DeserializeFailure::FixedValueMismatch {
279                            found: Key::Uint(tag_value),
280                            expected: Key::Uint(1),
281                        }
282                        .into());
283                    }
284                    Ok(Some(tag_encoding))
285                })()
286                .map_err(|e| e.annotate("tag"))?;
287                let (hash, hash_encoding) = raw
288                    .bytes_sz()
289                    .map_err(Into::<DeserializeError>::into)
290                    .and_then(|(bytes, enc)| {
291                        NonceHash::from_raw_bytes(&bytes)
292                            .map(|bytes| (bytes, StringEncoding::from(enc)))
293                            .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
294                    })
295                    .map_err(|e: DeserializeError| e.annotate("hash"))?;
296                match len {
297                    cbor_event::LenSz::Len(_, _) => (),
298                    cbor_event::LenSz::Indefinite => match raw.special()? {
299                        cbor_event::Special::Break => (),
300                        _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
301                    },
302                }
303                Ok(Self::Hash {
304                    hash,
305                    len_encoding,
306                    tag_encoding,
307                    hash_encoding,
308                })
309            })(raw);
310            match variant_deser {
311                Ok(variant) => return Ok(variant),
312                Err(e) => {
313                    errs.push(e.annotate("Hash"));
314                    raw.as_mut_ref()
315                        .seek(SeekFrom::Start(initial_position))
316                        .unwrap();
317                }
318            };
319            Err(DeserializeError::new(
320                "Nonce",
321                DeserializeFailure::NoVariantMatchedWithCauses(errs),
322            ))
323        })()
324        .map_err(|e| e.annotate("Nonce"))
325    }
326}
327
328impl Serialize for VRFCert {
329    fn serialize<'se, W: Write>(
330        &self,
331        serializer: &'se mut Serializer<W>,
332        force_canonical: bool,
333    ) -> cbor_event::Result<&'se mut Serializer<W>> {
334        serializer.write_array_sz(
335            self.encodings
336                .as_ref()
337                .map(|encs| encs.len_encoding)
338                .unwrap_or_default()
339                .to_len_sz(2, force_canonical),
340        )?;
341        serializer.write_bytes_sz(
342            &self.output,
343            self.encodings
344                .as_ref()
345                .map(|encs| encs.output_encoding.clone())
346                .unwrap_or_default()
347                .to_str_len_sz(self.output.len() as u64, force_canonical),
348        )?;
349        serializer.write_bytes_sz(
350            &self.proof,
351            self.encodings
352                .as_ref()
353                .map(|encs| encs.proof_encoding.clone())
354                .unwrap_or_default()
355                .to_str_len_sz(self.proof.len() as u64, force_canonical),
356        )?;
357        self.encodings
358            .as_ref()
359            .map(|encs| encs.len_encoding)
360            .unwrap_or_default()
361            .end(serializer, force_canonical)
362    }
363}
364
365impl Deserialize for VRFCert {
366    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
367        let len = raw.array_sz()?;
368        let len_encoding: LenEncoding = len.into();
369        let mut read_len = CBORReadLen::new(len);
370        read_len.read_elems(2)?;
371        read_len.finish()?;
372        (|| -> Result<_, DeserializeError> {
373            let (output, output_encoding) = raw
374                .bytes_sz()
375                .map_err(Into::<DeserializeError>::into)
376                .map(|(bytes, enc)| (bytes, StringEncoding::from(enc)))
377                .map_err(|e: DeserializeError| e.annotate("output"))?;
378            let (proof, proof_encoding) = raw
379                .bytes_sz()
380                .map_err(Into::<DeserializeError>::into)
381                .map_err(Into::<DeserializeError>::into)
382                .and_then(|(bytes, enc)| {
383                    if bytes.len() < 80 || bytes.len() > 80 {
384                        Err(DeserializeFailure::RangeCheck {
385                            found: bytes.len() as isize,
386                            min: Some(80),
387                            max: Some(80),
388                        }
389                        .into())
390                    } else {
391                        Ok((bytes, StringEncoding::from(enc)))
392                    }
393                })
394                .map_err(|e: DeserializeError| e.annotate("proof"))?;
395            match len {
396                cbor_event::LenSz::Len(_, _) => (),
397                cbor_event::LenSz::Indefinite => match raw.special()? {
398                    cbor_event::Special::Break => (),
399                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
400                },
401            }
402            Ok(VRFCert {
403                output,
404                proof,
405                encodings: Some(VRFCertEncoding {
406                    len_encoding,
407                    output_encoding,
408                    proof_encoding,
409                }),
410            })
411        })()
412        .map_err(|e| e.annotate("VRFCert"))
413    }
414}
415
416impl Serialize for Vkeywitness {
417    fn serialize<'se, W: Write>(
418        &self,
419        serializer: &'se mut Serializer<W>,
420        force_canonical: bool,
421    ) -> cbor_event::Result<&'se mut Serializer<W>> {
422        serializer.write_array_sz(
423            self.encodings
424                .as_ref()
425                .map(|encs| encs.len_encoding)
426                .unwrap_or_default()
427                .to_len_sz(2, force_canonical),
428        )?;
429        serializer.write_bytes_sz(
430            self.vkey.to_raw_bytes(),
431            self.encodings
432                .as_ref()
433                .map(|encs| encs.vkey_encoding.clone())
434                .unwrap_or_default()
435                .to_str_len_sz(self.vkey.to_raw_bytes().len() as u64, force_canonical),
436        )?;
437        serializer.write_bytes_sz(
438            self.ed25519_signature.to_raw_bytes(),
439            self.encodings
440                .as_ref()
441                .map(|encs| encs.ed25519_signature_encoding.clone())
442                .unwrap_or_default()
443                .to_str_len_sz(
444                    self.ed25519_signature.to_raw_bytes().len() as u64,
445                    force_canonical,
446                ),
447        )?;
448        self.encodings
449            .as_ref()
450            .map(|encs| encs.len_encoding)
451            .unwrap_or_default()
452            .end(serializer, force_canonical)
453    }
454}
455
456impl Deserialize for Vkeywitness {
457    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
458        let len = raw.array_sz()?;
459        let len_encoding: LenEncoding = len.into();
460        let mut read_len = CBORReadLen::new(len);
461        read_len.read_elems(2)?;
462        read_len.finish()?;
463        (|| -> Result<_, DeserializeError> {
464            let (vkey, vkey_encoding) = raw
465                .bytes_sz()
466                .map_err(Into::<DeserializeError>::into)
467                .and_then(|(bytes, enc)| {
468                    Vkey::from_raw_bytes(&bytes)
469                        .map(|bytes| (bytes, StringEncoding::from(enc)))
470                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
471                })
472                .map_err(|e: DeserializeError| e.annotate("vkey"))?;
473            let (ed25519_signature, ed25519_signature_encoding) = raw
474                .bytes_sz()
475                .map_err(Into::<DeserializeError>::into)
476                .and_then(|(bytes, enc)| {
477                    Ed25519Signature::from_raw_bytes(&bytes)
478                        .map(|bytes| (bytes, StringEncoding::from(enc)))
479                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
480                })
481                .map_err(|e: DeserializeError| e.annotate("ed25519_signature"))?;
482            match len {
483                cbor_event::LenSz::Len(_, _) => (),
484                cbor_event::LenSz::Indefinite => match raw.special()? {
485                    cbor_event::Special::Break => (),
486                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
487                },
488            }
489            Ok(Vkeywitness {
490                vkey,
491                ed25519_signature,
492                encodings: Some(VkeywitnessEncoding {
493                    len_encoding,
494                    vkey_encoding,
495                    ed25519_signature_encoding,
496                }),
497            })
498        })()
499        .map_err(|e| e.annotate("Vkeywitness"))
500    }
501}
cml_chain/crypto/serialization.rs

cml_chain/crypto/
serialization.rs
