1use super::cbor_encodings::*;
5use super::*;
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, Write};
12
13impl Serialize for Block {
14 fn serialize<'se, W: Write>(
15 &self,
16 serializer: &'se mut Serializer<W>,
17 force_canonical: bool,
18 ) -> cbor_event::Result<&'se mut Serializer<W>> {
19 serializer.write_array_sz(
20 self.encodings
21 .as_ref()
22 .map(|encs| encs.len_encoding)
23 .unwrap_or_default()
24 .to_len_sz(5, force_canonical),
25 )?;
26 self.header.serialize(serializer, force_canonical)?;
27 serializer.write_array_sz(
28 self.encodings
29 .as_ref()
30 .map(|encs| encs.transaction_bodies_encoding)
31 .unwrap_or_default()
32 .to_len_sz(self.transaction_bodies.len() as u64, force_canonical),
33 )?;
34 for element in self.transaction_bodies.iter() {
35 element.serialize(serializer, force_canonical)?;
36 }
37 self.encodings
38 .as_ref()
39 .map(|encs| encs.transaction_bodies_encoding)
40 .unwrap_or_default()
41 .end(serializer, force_canonical)?;
42 serializer.write_array_sz(
43 self.encodings
44 .as_ref()
45 .map(|encs| encs.transaction_witness_sets_encoding)
46 .unwrap_or_default()
47 .to_len_sz(self.transaction_witness_sets.len() as u64, force_canonical),
48 )?;
49 for element in self.transaction_witness_sets.iter() {
50 element.serialize(serializer, force_canonical)?;
51 }
52 self.encodings
53 .as_ref()
54 .map(|encs| encs.transaction_witness_sets_encoding)
55 .unwrap_or_default()
56 .end(serializer, force_canonical)?;
57 serializer.write_map_sz(
58 self.encodings
59 .as_ref()
60 .map(|encs| encs.auxiliary_data_set_encoding)
61 .unwrap_or_default()
62 .to_len_sz(self.auxiliary_data_set.len() as u64, force_canonical),
63 )?;
64 let mut key_order = self
65 .auxiliary_data_set
66 .iter()
67 .map(|(k, v)| {
68 let mut buf = cbor_event::se::Serializer::new_vec();
69 let auxiliary_data_set_key_encoding = self
70 .encodings
71 .as_ref()
72 .and_then(|encs| encs.auxiliary_data_set_key_encodings.get(k))
73 .cloned()
74 .unwrap_or_default();
75 buf.write_unsigned_integer_sz(
76 *k as u64,
77 fit_sz(*k as u64, auxiliary_data_set_key_encoding, force_canonical),
78 )?;
79 Ok((buf.finalize(), k, v))
80 })
81 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
82 if force_canonical {
83 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
84 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
85 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
86 diff_ord => diff_ord,
87 }
88 });
89 }
90 for (key_bytes, _key, value) in key_order {
91 serializer.write_raw_bytes(&key_bytes)?;
92 value.serialize(serializer, force_canonical)?;
93 }
94 self.encodings
95 .as_ref()
96 .map(|encs| encs.auxiliary_data_set_encoding)
97 .unwrap_or_default()
98 .end(serializer, force_canonical)?;
99 serializer.write_array_sz(
100 self.encodings
101 .as_ref()
102 .map(|encs| encs.invalid_transactions_encoding)
103 .unwrap_or_default()
104 .to_len_sz(self.invalid_transactions.len() as u64, force_canonical),
105 )?;
106 for (i, element) in self.invalid_transactions.iter().enumerate() {
107 let invalid_transactions_elem_encoding = self
108 .encodings
109 .as_ref()
110 .and_then(|encs| encs.invalid_transactions_elem_encodings.get(i))
111 .cloned()
112 .unwrap_or_default();
113 serializer.write_unsigned_integer_sz(
114 *element as u64,
115 fit_sz(
116 *element as u64,
117 invalid_transactions_elem_encoding,
118 force_canonical,
119 ),
120 )?;
121 }
122 self.encodings
123 .as_ref()
124 .map(|encs| encs.invalid_transactions_encoding)
125 .unwrap_or_default()
126 .end(serializer, force_canonical)?;
127 self.encodings
128 .as_ref()
129 .map(|encs| encs.len_encoding)
130 .unwrap_or_default()
131 .end(serializer, force_canonical)
132 }
133}
134
135impl Deserialize for Block {
136 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
137 let len = raw.array_sz()?;
138 let len_encoding: LenEncoding = len.into();
139 let mut read_len = CBORReadLen::new(len);
140 read_len.read_elems(5)?;
141 read_len.finish()?;
142 (|| -> Result<_, DeserializeError> {
143 let header = Header::deserialize(raw).map_err(|e: DeserializeError| e.annotate("header"))?;
144 let (transaction_bodies, transaction_bodies_encoding) = (|| -> Result<_, DeserializeError> {
145 let mut transaction_bodies_arr = Vec::new();
146 let len = raw.array_sz()?;
147 let transaction_bodies_encoding = len.into();
148 while match len { cbor_event::LenSz::Len(n, _) => (transaction_bodies_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
149 if raw.cbor_type()? == cbor_event::Type::Special {
150 assert_eq!(raw.special()?, cbor_event::Special::Break);
151 break;
152 }
153 transaction_bodies_arr.push(TransactionBody::deserialize(raw)?);
154 }
155 Ok((transaction_bodies_arr, transaction_bodies_encoding))
156 })().map_err(|e| e.annotate("transaction_bodies"))?;
157 let (transaction_witness_sets, transaction_witness_sets_encoding) = (|| -> Result<_, DeserializeError> {
158 let mut transaction_witness_sets_arr = Vec::new();
159 let len = raw.array_sz()?;
160 let transaction_witness_sets_encoding = len.into();
161 while match len { cbor_event::LenSz::Len(n, _) => (transaction_witness_sets_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
162 if raw.cbor_type()? == cbor_event::Type::Special {
163 assert_eq!(raw.special()?, cbor_event::Special::Break);
164 break;
165 }
166 transaction_witness_sets_arr.push(TransactionWitnessSet::deserialize(raw)?);
167 }
168 Ok((transaction_witness_sets_arr, transaction_witness_sets_encoding))
169 })().map_err(|e| e.annotate("transaction_witness_sets"))?;
170 let (auxiliary_data_set, auxiliary_data_set_encoding, auxiliary_data_set_key_encodings) = (|| -> Result<_, DeserializeError> {
171 let mut auxiliary_data_set_table = OrderedHashMap::new();
172 let auxiliary_data_set_len = raw.map_sz()?;
173 let auxiliary_data_set_encoding = auxiliary_data_set_len.into();
174 let mut auxiliary_data_set_key_encodings = BTreeMap::new();
175 while match auxiliary_data_set_len { cbor_event::LenSz::Len(n, _) => (auxiliary_data_set_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
176 if raw.cbor_type()? == cbor_event::Type::Special {
177 assert_eq!(raw.special()?, cbor_event::Special::Break);
178 break;
179 }
180 let (auxiliary_data_set_key, auxiliary_data_set_key_encoding) = raw.unsigned_integer_sz().map(|(x, enc)| (x as u16, Some(enc)))?;
181 let auxiliary_data_set_value = AuxiliaryData::deserialize(raw)?;
182 if auxiliary_data_set_table.insert(auxiliary_data_set_key, auxiliary_data_set_value).is_some() {
183 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
184 }
185 auxiliary_data_set_key_encodings.insert(auxiliary_data_set_key, auxiliary_data_set_key_encoding);
186 }
187 Ok((auxiliary_data_set_table, auxiliary_data_set_encoding, auxiliary_data_set_key_encodings))
188 })().map_err(|e| e.annotate("auxiliary_data_set"))?;
189 let (invalid_transactions, invalid_transactions_encoding, invalid_transactions_elem_encodings) = (|| -> Result<_, DeserializeError> {
190 let mut invalid_transactions_arr = Vec::new();
191 let len = raw.array_sz()?;
192 let invalid_transactions_encoding = len.into();
193 let mut invalid_transactions_elem_encodings = Vec::new();
194 while match len { cbor_event::LenSz::Len(n, _) => (invalid_transactions_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
195 if raw.cbor_type()? == cbor_event::Type::Special {
196 assert_eq!(raw.special()?, cbor_event::Special::Break);
197 break;
198 }
199 let (invalid_transactions_elem, invalid_transactions_elem_encoding) = raw.unsigned_integer_sz().map(|(x, enc)| (x as u16, Some(enc)))?;
200 invalid_transactions_arr.push(invalid_transactions_elem);
201 invalid_transactions_elem_encodings.push(invalid_transactions_elem_encoding);
202 }
203 Ok((invalid_transactions_arr, invalid_transactions_encoding, invalid_transactions_elem_encodings))
204 })().map_err(|e| e.annotate("invalid_transactions"))?;
205 match len {
206 cbor_event::LenSz::Len(_, _) => (),
207 cbor_event::LenSz::Indefinite => match raw.special()? {
208 cbor_event::Special::Break => (),
209 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
210 },
211 }
212 Ok(Block {
213 header,
214 transaction_bodies,
215 transaction_witness_sets,
216 auxiliary_data_set,
217 invalid_transactions,
218 encodings: Some(BlockEncoding {
219 len_encoding,
220 transaction_bodies_encoding,
221 transaction_witness_sets_encoding,
222 auxiliary_data_set_encoding,
223 auxiliary_data_set_key_encodings,
224 invalid_transactions_encoding,
225 invalid_transactions_elem_encodings,
226 }),
227 })
228 })().map_err(|e| e.annotate("Block"))
229 }
230}
231
232impl Serialize for Header {
233 fn serialize<'se, W: Write>(
234 &self,
235 serializer: &'se mut Serializer<W>,
236 force_canonical: bool,
237 ) -> cbor_event::Result<&'se mut Serializer<W>> {
238 serializer.write_array_sz(
239 self.encodings
240 .as_ref()
241 .map(|encs| encs.len_encoding)
242 .unwrap_or_default()
243 .to_len_sz(2, force_canonical),
244 )?;
245 self.header_body.serialize(serializer, force_canonical)?;
246 self.body_signature.serialize(serializer, force_canonical)?;
247 self.encodings
248 .as_ref()
249 .map(|encs| encs.len_encoding)
250 .unwrap_or_default()
251 .end(serializer, force_canonical)
252 }
253}
254
255impl Deserialize for Header {
256 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
257 let len = raw.array_sz()?;
258 let len_encoding: LenEncoding = len.into();
259 let mut read_len = CBORReadLen::new(len);
260 read_len.read_elems(2)?;
261 read_len.finish()?;
262 (|| -> Result<_, DeserializeError> {
263 let header_body = HeaderBody::deserialize(raw)
264 .map_err(|e: DeserializeError| e.annotate("header_body"))?;
265 let body_signature = KESSignature::deserialize(raw)
266 .map_err(|e: DeserializeError| e.annotate("body_signature"))?;
267 match len {
268 cbor_event::LenSz::Len(_, _) => (),
269 cbor_event::LenSz::Indefinite => match raw.special()? {
270 cbor_event::Special::Break => (),
271 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
272 },
273 }
274 Ok(Header {
275 header_body,
276 body_signature,
277 encodings: Some(HeaderEncoding { len_encoding }),
278 })
279 })()
280 .map_err(|e| e.annotate("Header"))
281 }
282}
283
284impl Serialize for HeaderBody {
285 fn serialize<'se, W: Write>(
286 &self,
287 serializer: &'se mut Serializer<W>,
288 force_canonical: bool,
289 ) -> cbor_event::Result<&'se mut Serializer<W>> {
290 serializer.write_array_sz(
291 self.encodings
292 .as_ref()
293 .map(|encs| encs.len_encoding)
294 .unwrap_or_default()
295 .to_len_sz(10, force_canonical),
296 )?;
297 serializer.write_unsigned_integer_sz(
298 self.block_number,
299 fit_sz(
300 self.block_number,
301 self.encodings
302 .as_ref()
303 .map(|encs| encs.block_number_encoding)
304 .unwrap_or_default(),
305 force_canonical,
306 ),
307 )?;
308 serializer.write_unsigned_integer_sz(
309 self.slot,
310 fit_sz(
311 self.slot,
312 self.encodings
313 .as_ref()
314 .map(|encs| encs.slot_encoding)
315 .unwrap_or_default(),
316 force_canonical,
317 ),
318 )?;
319 match &self.prev_hash {
320 Some(x) => serializer.write_bytes_sz(
321 x.to_raw_bytes(),
322 self.encodings
323 .as_ref()
324 .map(|encs| encs.prev_hash_encoding.clone())
325 .unwrap_or_default()
326 .to_str_len_sz(x.to_raw_bytes().len() as u64, force_canonical),
327 ),
328 None => serializer.write_special(cbor_event::Special::Null),
329 }?;
330 serializer.write_bytes_sz(
331 self.issuer_vkey.to_raw_bytes(),
332 self.encodings
333 .as_ref()
334 .map(|encs| encs.issuer_vkey_encoding.clone())
335 .unwrap_or_default()
336 .to_str_len_sz(
337 self.issuer_vkey.to_raw_bytes().len() as u64,
338 force_canonical,
339 ),
340 )?;
341 serializer.write_bytes_sz(
342 self.vrf_vkey.to_raw_bytes(),
343 self.encodings
344 .as_ref()
345 .map(|encs| encs.vrf_vkey_encoding.clone())
346 .unwrap_or_default()
347 .to_str_len_sz(self.vrf_vkey.to_raw_bytes().len() as u64, force_canonical),
348 )?;
349 self.vrf_result.serialize(serializer, force_canonical)?;
350 serializer.write_unsigned_integer_sz(
351 self.block_body_size,
352 fit_sz(
353 self.block_body_size,
354 self.encodings
355 .as_ref()
356 .map(|encs| encs.block_body_size_encoding)
357 .unwrap_or_default(),
358 force_canonical,
359 ),
360 )?;
361 serializer.write_bytes_sz(
362 self.block_body_hash.to_raw_bytes(),
363 self.encodings
364 .as_ref()
365 .map(|encs| encs.block_body_hash_encoding.clone())
366 .unwrap_or_default()
367 .to_str_len_sz(
368 self.block_body_hash.to_raw_bytes().len() as u64,
369 force_canonical,
370 ),
371 )?;
372 self.operational_cert
373 .serialize(serializer, force_canonical)?;
374 self.protocol_version
375 .serialize(serializer, force_canonical)?;
376 self.encodings
377 .as_ref()
378 .map(|encs| encs.len_encoding)
379 .unwrap_or_default()
380 .end(serializer, force_canonical)
381 }
382}
383
384impl Deserialize for HeaderBody {
385 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
386 let len = raw.array_sz()?;
387 let len_encoding: LenEncoding = len.into();
388 let mut read_len = CBORReadLen::new(len);
389 read_len.read_elems(10)?;
390 read_len.finish()?;
391 (|| -> Result<_, DeserializeError> {
392 let (block_number, block_number_encoding) = raw
393 .unsigned_integer_sz()
394 .map_err(Into::<DeserializeError>::into)
395 .map(|(x, enc)| (x, Some(enc)))
396 .map_err(|e: DeserializeError| e.annotate("block_number"))?;
397 let (slot, slot_encoding) = raw
398 .unsigned_integer_sz()
399 .map_err(Into::<DeserializeError>::into)
400 .map(|(x, enc)| (x, Some(enc)))
401 .map_err(|e: DeserializeError| e.annotate("slot"))?;
402 let (prev_hash, prev_hash_encoding) = (|| -> Result<_, DeserializeError> {
403 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
404 true => Result::<_, DeserializeError>::Ok(
405 raw.bytes_sz()
406 .map_err(Into::<DeserializeError>::into)
407 .and_then(|(bytes, enc)| {
408 BlockHeaderHash::from_raw_bytes(&bytes)
409 .map(|bytes| (bytes, StringEncoding::from(enc)))
410 .map_err(|e| {
411 DeserializeFailure::InvalidStructure(Box::new(e)).into()
412 })
413 })?,
414 )
415 .map(|(x, prev_hash_encoding)| (Some(x), prev_hash_encoding))?,
416 false => {
417 if raw.special()? != cbor_event::Special::Null {
418 return Err(DeserializeFailure::ExpectedNull.into());
419 }
420 (None, StringEncoding::default())
421 }
422 })
423 })()
424 .map_err(|e| e.annotate("prev_hash"))?;
425 let (issuer_vkey, issuer_vkey_encoding) = raw
426 .bytes_sz()
427 .map_err(Into::<DeserializeError>::into)
428 .and_then(|(bytes, enc)| {
429 Vkey::from_raw_bytes(&bytes)
430 .map(|bytes| (bytes, StringEncoding::from(enc)))
431 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
432 })
433 .map_err(|e: DeserializeError| e.annotate("issuer_vkey"))?;
434 let (vrf_vkey, vrf_vkey_encoding) = raw
435 .bytes_sz()
436 .map_err(Into::<DeserializeError>::into)
437 .and_then(|(bytes, enc)| {
438 VRFVkey::from_raw_bytes(&bytes)
439 .map(|bytes| (bytes, StringEncoding::from(enc)))
440 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
441 })
442 .map_err(|e: DeserializeError| e.annotate("vrf_vkey"))?;
443 let vrf_result = VRFCert::deserialize(raw)
444 .map_err(|e: DeserializeError| e.annotate("vrf_result"))?;
445 let (block_body_size, block_body_size_encoding) = raw
446 .unsigned_integer_sz()
447 .map_err(Into::<DeserializeError>::into)
448 .map(|(x, enc)| (x, Some(enc)))
449 .map_err(|e: DeserializeError| e.annotate("block_body_size"))?;
450 let (block_body_hash, block_body_hash_encoding) = raw
451 .bytes_sz()
452 .map_err(Into::<DeserializeError>::into)
453 .and_then(|(bytes, enc)| {
454 BlockBodyHash::from_raw_bytes(&bytes)
455 .map(|bytes| (bytes, StringEncoding::from(enc)))
456 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
457 })
458 .map_err(|e: DeserializeError| e.annotate("block_body_hash"))?;
459 let operational_cert = OperationalCert::deserialize(raw)
460 .map_err(|e: DeserializeError| e.annotate("operational_cert"))?;
461 let protocol_version = ProtocolVersion::deserialize(raw)
462 .map_err(|e: DeserializeError| e.annotate("protocol_version"))?;
463 match len {
464 cbor_event::LenSz::Len(_, _) => (),
465 cbor_event::LenSz::Indefinite => match raw.special()? {
466 cbor_event::Special::Break => (),
467 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
468 },
469 }
470 Ok(HeaderBody {
471 block_number,
472 slot,
473 prev_hash,
474 issuer_vkey,
475 vrf_vkey,
476 vrf_result,
477 block_body_size,
478 block_body_hash,
479 operational_cert,
480 protocol_version,
481 encodings: Some(HeaderBodyEncoding {
482 len_encoding,
483 block_number_encoding,
484 slot_encoding,
485 prev_hash_encoding,
486 issuer_vkey_encoding,
487 vrf_vkey_encoding,
488 block_body_size_encoding,
489 block_body_hash_encoding,
490 }),
491 })
492 })()
493 .map_err(|e| e.annotate("HeaderBody"))
494 }
495}
496
497impl Serialize for OperationalCert {
498 fn serialize<'se, W: Write>(
499 &self,
500 serializer: &'se mut Serializer<W>,
501 force_canonical: bool,
502 ) -> cbor_event::Result<&'se mut Serializer<W>> {
503 serializer.write_array_sz(
504 self.encodings
505 .as_ref()
506 .map(|encs| encs.len_encoding)
507 .unwrap_or_default()
508 .to_len_sz(4, force_canonical),
509 )?;
510 self.serialize_as_embedded_group(serializer, force_canonical)
511 }
512}
513
514impl SerializeEmbeddedGroup for OperationalCert {
515 fn serialize_as_embedded_group<'se, W: Write>(
516 &self,
517 serializer: &'se mut Serializer<W>,
518 force_canonical: bool,
519 ) -> cbor_event::Result<&'se mut Serializer<W>> {
520 serializer.write_bytes_sz(
521 self.hot_vkey.to_raw_bytes(),
522 self.encodings
523 .as_ref()
524 .map(|encs| encs.hot_vkey_encoding.clone())
525 .unwrap_or_default()
526 .to_str_len_sz(self.hot_vkey.to_raw_bytes().len() as u64, force_canonical),
527 )?;
528 serializer.write_unsigned_integer_sz(
529 self.sequence_number,
530 fit_sz(
531 self.sequence_number,
532 self.encodings
533 .as_ref()
534 .map(|encs| encs.sequence_number_encoding)
535 .unwrap_or_default(),
536 force_canonical,
537 ),
538 )?;
539 serializer.write_unsigned_integer_sz(
540 self.kes_period,
541 fit_sz(
542 self.kes_period,
543 self.encodings
544 .as_ref()
545 .map(|encs| encs.kes_period_encoding)
546 .unwrap_or_default(),
547 force_canonical,
548 ),
549 )?;
550 serializer.write_bytes_sz(
551 self.sigma.to_raw_bytes(),
552 self.encodings
553 .as_ref()
554 .map(|encs| encs.sigma_encoding.clone())
555 .unwrap_or_default()
556 .to_str_len_sz(self.sigma.to_raw_bytes().len() as u64, force_canonical),
557 )?;
558 self.encodings
559 .as_ref()
560 .map(|encs| encs.len_encoding)
561 .unwrap_or_default()
562 .end(serializer, force_canonical)
563 }
564}
565
566impl Deserialize for OperationalCert {
567 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
568 let len = raw.array_sz()?;
569 let mut read_len = CBORReadLen::new(len);
570 read_len.read_elems(4)?;
571 read_len.finish()?;
572 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
573 match len {
574 cbor_event::LenSz::Len(_, _) => (),
575 cbor_event::LenSz::Indefinite => match raw.special()? {
576 cbor_event::Special::Break => (),
577 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
578 },
579 }
580 ret
581 }
582}
583
584impl DeserializeEmbeddedGroup for OperationalCert {
585 fn deserialize_as_embedded_group<R: BufRead + Seek>(
586 raw: &mut Deserializer<R>,
587 _read_len: &mut CBORReadLen,
588 len: cbor_event::LenSz,
589 ) -> Result<Self, DeserializeError> {
590 let len_encoding = len.into();
591 (|| -> Result<_, DeserializeError> {
592 let (hot_vkey, hot_vkey_encoding) = raw
593 .bytes_sz()
594 .map_err(Into::<DeserializeError>::into)
595 .and_then(|(bytes, enc)| {
596 KESVkey::from_raw_bytes(&bytes)
597 .map(|bytes| (bytes, StringEncoding::from(enc)))
598 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
599 })
600 .map_err(|e: DeserializeError| e.annotate("hot_vkey"))?;
601 let (sequence_number, sequence_number_encoding) = raw
602 .unsigned_integer_sz()
603 .map_err(Into::<DeserializeError>::into)
604 .map(|(x, enc)| (x, Some(enc)))
605 .map_err(|e: DeserializeError| e.annotate("sequence_number"))?;
606 let (kes_period, kes_period_encoding) = raw
607 .unsigned_integer_sz()
608 .map_err(Into::<DeserializeError>::into)
609 .map(|(x, enc)| (x, Some(enc)))
610 .map_err(|e: DeserializeError| e.annotate("kes_period"))?;
611 let (sigma, sigma_encoding) = raw
612 .bytes_sz()
613 .map_err(Into::<DeserializeError>::into)
614 .and_then(|(bytes, enc)| {
615 Ed25519Signature::from_raw_bytes(&bytes)
616 .map(|bytes| (bytes, StringEncoding::from(enc)))
617 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
618 })
619 .map_err(|e: DeserializeError| e.annotate("sigma"))?;
620 Ok(OperationalCert {
621 hot_vkey,
622 sequence_number,
623 kes_period,
624 sigma,
625 encodings: Some(OperationalCertEncoding {
626 len_encoding,
627 hot_vkey_encoding,
628 sequence_number_encoding,
629 kes_period_encoding,
630 sigma_encoding,
631 }),
632 })
633 })()
634 .map_err(|e| e.annotate("OperationalCert"))
635 }
636}
637
638impl Serialize for ProtocolVersion {
639 fn serialize<'se, W: Write>(
640 &self,
641 serializer: &'se mut Serializer<W>,
642 force_canonical: bool,
643 ) -> cbor_event::Result<&'se mut Serializer<W>> {
644 serializer.write_array_sz(
645 self.encodings
646 .as_ref()
647 .map(|encs| encs.len_encoding)
648 .unwrap_or_default()
649 .to_len_sz(2, force_canonical),
650 )?;
651 self.serialize_as_embedded_group(serializer, force_canonical)
652 }
653}
654
655impl SerializeEmbeddedGroup for ProtocolVersion {
656 fn serialize_as_embedded_group<'se, W: Write>(
657 &self,
658 serializer: &'se mut Serializer<W>,
659 force_canonical: bool,
660 ) -> cbor_event::Result<&'se mut Serializer<W>> {
661 serializer.write_unsigned_integer_sz(
662 self.major,
663 fit_sz(
664 self.major,
665 self.encodings
666 .as_ref()
667 .map(|encs| encs.major_encoding)
668 .unwrap_or_default(),
669 force_canonical,
670 ),
671 )?;
672 serializer.write_unsigned_integer_sz(
673 self.minor,
674 fit_sz(
675 self.minor,
676 self.encodings
677 .as_ref()
678 .map(|encs| encs.minor_encoding)
679 .unwrap_or_default(),
680 force_canonical,
681 ),
682 )?;
683 self.encodings
684 .as_ref()
685 .map(|encs| encs.len_encoding)
686 .unwrap_or_default()
687 .end(serializer, force_canonical)
688 }
689}
690
691impl Deserialize for ProtocolVersion {
692 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
693 let len = raw.array_sz()?;
694 let mut read_len = CBORReadLen::new(len);
695 read_len.read_elems(2)?;
696 read_len.finish()?;
697 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
698 match len {
699 cbor_event::LenSz::Len(_, _) => (),
700 cbor_event::LenSz::Indefinite => match raw.special()? {
701 cbor_event::Special::Break => (),
702 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
703 },
704 }
705 ret
706 }
707}
708
709impl DeserializeEmbeddedGroup for ProtocolVersion {
710 fn deserialize_as_embedded_group<R: BufRead + Seek>(
711 raw: &mut Deserializer<R>,
712 _read_len: &mut CBORReadLen,
713 len: cbor_event::LenSz,
714 ) -> Result<Self, DeserializeError> {
715 let len_encoding = len.into();
716 (|| -> Result<_, DeserializeError> {
717 let (major, major_encoding) = raw
718 .unsigned_integer_sz()
719 .map_err(Into::<DeserializeError>::into)
720 .map(|(x, enc)| (x, Some(enc)))
721 .map_err(|e: DeserializeError| e.annotate("major"))?;
722 let (minor, minor_encoding) = raw
723 .unsigned_integer_sz()
724 .map_err(Into::<DeserializeError>::into)
725 .map(|(x, enc)| (x, Some(enc)))
726 .map_err(|e: DeserializeError| e.annotate("minor"))?;
727 Ok(ProtocolVersion {
728 major,
729 minor,
730 encodings: Some(ProtocolVersionEncoding {
731 len_encoding,
732 major_encoding,
733 minor_encoding,
734 }),
735 })
736 })()
737 .map_err(|e| e.annotate("ProtocolVersion"))
738 }
739}