1use super::cbor_encodings::*;
5use super::*;
6use cbor_event;
7use cbor_event::de::Deserializer;
8use cbor_event::se::Serializer;
9use cml_chain::address::RewardAccount;
10use cml_chain::certs::{PoolMetadata, SingleHostAddr};
11use cml_core::error::*;
12use cml_core::serialization::*;
13use cml_crypto::GenesisDelegateHash;
14use cml_crypto::RawBytesEncoding;
15use cml_crypto::VRFKeyHash;
16use std::io::{BufRead, Seek, SeekFrom, Write};
17
18impl Serialize for GenesisKeyDelegation {
19 fn serialize<'se, W: Write>(
20 &self,
21 serializer: &'se mut Serializer<W>,
22 force_canonical: bool,
23 ) -> cbor_event::Result<&'se mut Serializer<W>> {
24 serializer.write_array_sz(
25 self.encodings
26 .as_ref()
27 .map(|encs| encs.len_encoding)
28 .unwrap_or_default()
29 .to_len_sz(4, force_canonical),
30 )?;
31 self.serialize_as_embedded_group(serializer, force_canonical)
32 }
33}
34
35impl SerializeEmbeddedGroup for GenesisKeyDelegation {
36 fn serialize_as_embedded_group<'se, W: Write>(
37 &self,
38 serializer: &'se mut Serializer<W>,
39 force_canonical: bool,
40 ) -> cbor_event::Result<&'se mut Serializer<W>> {
41 serializer.write_unsigned_integer_sz(
42 5u64,
43 fit_sz(
44 5u64,
45 self.encodings
46 .as_ref()
47 .map(|encs| encs.tag_encoding)
48 .unwrap_or_default(),
49 force_canonical,
50 ),
51 )?;
52 serializer.write_bytes_sz(
53 self.genesis_hash.to_raw_bytes(),
54 self.encodings
55 .as_ref()
56 .map(|encs| encs.genesis_hash_encoding.clone())
57 .unwrap_or_default()
58 .to_str_len_sz(
59 self.genesis_hash.to_raw_bytes().len() as u64,
60 force_canonical,
61 ),
62 )?;
63 serializer.write_bytes_sz(
64 self.genesis_delegate_hash.to_raw_bytes(),
65 self.encodings
66 .as_ref()
67 .map(|encs| encs.genesis_delegate_hash_encoding.clone())
68 .unwrap_or_default()
69 .to_str_len_sz(
70 self.genesis_delegate_hash.to_raw_bytes().len() as u64,
71 force_canonical,
72 ),
73 )?;
74 serializer.write_bytes_sz(
75 self.vrf_key_hash.to_raw_bytes(),
76 self.encodings
77 .as_ref()
78 .map(|encs| encs.vrf_key_hash_encoding.clone())
79 .unwrap_or_default()
80 .to_str_len_sz(
81 self.vrf_key_hash.to_raw_bytes().len() as u64,
82 force_canonical,
83 ),
84 )?;
85 self.encodings
86 .as_ref()
87 .map(|encs| encs.len_encoding)
88 .unwrap_or_default()
89 .end(serializer, force_canonical)
90 }
91}
92
93impl Deserialize for GenesisKeyDelegation {
94 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
95 let len = raw.array_sz()?;
96 let mut read_len = CBORReadLen::new(len);
97 read_len.read_elems(4)?;
98 read_len.finish()?;
99 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
100 match len {
101 cbor_event::LenSz::Len(_, _) => (),
102 cbor_event::LenSz::Indefinite => match raw.special()? {
103 cbor_event::Special::Break => (),
104 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
105 },
106 }
107 ret
108 }
109}
110
111impl DeserializeEmbeddedGroup for GenesisKeyDelegation {
112 fn deserialize_as_embedded_group<R: BufRead + Seek>(
113 raw: &mut Deserializer<R>,
114 _read_len: &mut CBORReadLen,
115 len: cbor_event::LenSz,
116 ) -> Result<Self, DeserializeError> {
117 let len_encoding = len.into();
118 (|| -> Result<_, DeserializeError> {
119 let tag_encoding = (|| -> Result<_, DeserializeError> {
120 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
121 if tag_value != 5 {
122 return Err(DeserializeFailure::FixedValueMismatch {
123 found: Key::Uint(tag_value),
124 expected: Key::Uint(5),
125 }
126 .into());
127 }
128 Ok(Some(tag_encoding))
129 })()
130 .map_err(|e| e.annotate("tag"))?;
131 let (genesis_hash, genesis_hash_encoding) = raw
132 .bytes_sz()
133 .map_err(Into::<DeserializeError>::into)
134 .and_then(|(bytes, enc)| {
135 GenesisHash::from_raw_bytes(&bytes)
136 .map(|bytes| (bytes, StringEncoding::from(enc)))
137 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
138 })
139 .map_err(|e: DeserializeError| e.annotate("genesis_hash"))?;
140 let (genesis_delegate_hash, genesis_delegate_hash_encoding) = raw
141 .bytes_sz()
142 .map_err(Into::<DeserializeError>::into)
143 .and_then(|(bytes, enc)| {
144 GenesisDelegateHash::from_raw_bytes(&bytes)
145 .map(|bytes| (bytes, StringEncoding::from(enc)))
146 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
147 })
148 .map_err(|e: DeserializeError| e.annotate("genesis_delegate_hash"))?;
149 let (vrf_key_hash, vrf_key_hash_encoding) = raw
150 .bytes_sz()
151 .map_err(Into::<DeserializeError>::into)
152 .and_then(|(bytes, enc)| {
153 VRFKeyHash::from_raw_bytes(&bytes)
154 .map(|bytes| (bytes, StringEncoding::from(enc)))
155 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
156 })
157 .map_err(|e: DeserializeError| e.annotate("vrf_key_hash"))?;
158 Ok(GenesisKeyDelegation {
159 genesis_hash,
160 genesis_delegate_hash,
161 vrf_key_hash,
162 encodings: Some(GenesisKeyDelegationEncoding {
163 len_encoding,
164 tag_encoding,
165 genesis_hash_encoding,
166 genesis_delegate_hash_encoding,
167 vrf_key_hash_encoding,
168 }),
169 })
170 })()
171 .map_err(|e| e.annotate("GenesisKeyDelegation"))
172 }
173}
174
175impl Serialize for MultisigAll {
176 fn serialize<'se, W: Write>(
177 &self,
178 serializer: &'se mut Serializer<W>,
179 force_canonical: bool,
180 ) -> cbor_event::Result<&'se mut Serializer<W>> {
181 serializer.write_array_sz(
182 self.encodings
183 .as_ref()
184 .map(|encs| encs.len_encoding)
185 .unwrap_or_default()
186 .to_len_sz(2, force_canonical),
187 )?;
188 self.serialize_as_embedded_group(serializer, force_canonical)
189 }
190}
191
192impl SerializeEmbeddedGroup for MultisigAll {
193 fn serialize_as_embedded_group<'se, W: Write>(
194 &self,
195 serializer: &'se mut Serializer<W>,
196 force_canonical: bool,
197 ) -> cbor_event::Result<&'se mut Serializer<W>> {
198 serializer.write_unsigned_integer_sz(
199 1u64,
200 fit_sz(
201 1u64,
202 self.encodings
203 .as_ref()
204 .map(|encs| encs.tag_encoding)
205 .unwrap_or_default(),
206 force_canonical,
207 ),
208 )?;
209 serializer.write_array_sz(
210 self.encodings
211 .as_ref()
212 .map(|encs| encs.multisig_scripts_encoding)
213 .unwrap_or_default()
214 .to_len_sz(self.multisig_scripts.len() as u64, force_canonical),
215 )?;
216 for element in self.multisig_scripts.iter() {
217 element.serialize(serializer, force_canonical)?;
218 }
219 self.encodings
220 .as_ref()
221 .map(|encs| encs.multisig_scripts_encoding)
222 .unwrap_or_default()
223 .end(serializer, force_canonical)?;
224 self.encodings
225 .as_ref()
226 .map(|encs| encs.len_encoding)
227 .unwrap_or_default()
228 .end(serializer, force_canonical)
229 }
230}
231
232impl Deserialize for MultisigAll {
233 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
234 let len = raw.array_sz()?;
235 let mut read_len = CBORReadLen::new(len);
236 read_len.read_elems(2)?;
237 read_len.finish()?;
238 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
239 match len {
240 cbor_event::LenSz::Len(_, _) => (),
241 cbor_event::LenSz::Indefinite => match raw.special()? {
242 cbor_event::Special::Break => (),
243 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
244 },
245 }
246 ret
247 }
248}
249
250impl DeserializeEmbeddedGroup for MultisigAll {
251 fn deserialize_as_embedded_group<R: BufRead + Seek>(
252 raw: &mut Deserializer<R>,
253 _read_len: &mut CBORReadLen,
254 len: cbor_event::LenSz,
255 ) -> Result<Self, DeserializeError> {
256 let len_encoding = len.into();
257 (|| -> Result<_, DeserializeError> {
258 let tag_encoding = (|| -> Result<_, DeserializeError> {
259 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
260 if tag_value != 1 {
261 return Err(DeserializeFailure::FixedValueMismatch {
262 found: Key::Uint(tag_value),
263 expected: Key::Uint(1),
264 }
265 .into());
266 }
267 Ok(Some(tag_encoding))
268 })()
269 .map_err(|e| e.annotate("tag"))?;
270 let (multisig_scripts, multisig_scripts_encoding) =
271 (|| -> Result<_, DeserializeError> {
272 let mut multisig_scripts_arr = Vec::new();
273 let len = raw.array_sz()?;
274 let multisig_scripts_encoding = len.into();
275 while match len {
276 cbor_event::LenSz::Len(n, _) => (multisig_scripts_arr.len() as u64) < n,
277 cbor_event::LenSz::Indefinite => true,
278 } {
279 if raw.cbor_type()? == cbor_event::Type::Special {
280 assert_eq!(raw.special()?, cbor_event::Special::Break);
281 break;
282 }
283 multisig_scripts_arr.push(MultisigScript::deserialize(raw)?);
284 }
285 Ok((multisig_scripts_arr, multisig_scripts_encoding))
286 })()
287 .map_err(|e| e.annotate("multisig_scripts"))?;
288 Ok(MultisigAll {
289 multisig_scripts,
290 encodings: Some(MultisigAllEncoding {
291 len_encoding,
292 tag_encoding,
293 multisig_scripts_encoding,
294 }),
295 })
296 })()
297 .map_err(|e| e.annotate("MultisigAll"))
298 }
299}
300
301impl Serialize for MultisigAny {
302 fn serialize<'se, W: Write>(
303 &self,
304 serializer: &'se mut Serializer<W>,
305 force_canonical: bool,
306 ) -> cbor_event::Result<&'se mut Serializer<W>> {
307 serializer.write_array_sz(
308 self.encodings
309 .as_ref()
310 .map(|encs| encs.len_encoding)
311 .unwrap_or_default()
312 .to_len_sz(2, force_canonical),
313 )?;
314 self.serialize_as_embedded_group(serializer, force_canonical)
315 }
316}
317
318impl SerializeEmbeddedGroup for MultisigAny {
319 fn serialize_as_embedded_group<'se, W: Write>(
320 &self,
321 serializer: &'se mut Serializer<W>,
322 force_canonical: bool,
323 ) -> cbor_event::Result<&'se mut Serializer<W>> {
324 serializer.write_unsigned_integer_sz(
325 2u64,
326 fit_sz(
327 2u64,
328 self.encodings
329 .as_ref()
330 .map(|encs| encs.tag_encoding)
331 .unwrap_or_default(),
332 force_canonical,
333 ),
334 )?;
335 serializer.write_array_sz(
336 self.encodings
337 .as_ref()
338 .map(|encs| encs.multisig_scripts_encoding)
339 .unwrap_or_default()
340 .to_len_sz(self.multisig_scripts.len() as u64, force_canonical),
341 )?;
342 for element in self.multisig_scripts.iter() {
343 element.serialize(serializer, force_canonical)?;
344 }
345 self.encodings
346 .as_ref()
347 .map(|encs| encs.multisig_scripts_encoding)
348 .unwrap_or_default()
349 .end(serializer, force_canonical)?;
350 self.encodings
351 .as_ref()
352 .map(|encs| encs.len_encoding)
353 .unwrap_or_default()
354 .end(serializer, force_canonical)
355 }
356}
357
358impl Deserialize for MultisigAny {
359 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
360 let len = raw.array_sz()?;
361 let mut read_len = CBORReadLen::new(len);
362 read_len.read_elems(2)?;
363 read_len.finish()?;
364 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
365 match len {
366 cbor_event::LenSz::Len(_, _) => (),
367 cbor_event::LenSz::Indefinite => match raw.special()? {
368 cbor_event::Special::Break => (),
369 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
370 },
371 }
372 ret
373 }
374}
375
376impl DeserializeEmbeddedGroup for MultisigAny {
377 fn deserialize_as_embedded_group<R: BufRead + Seek>(
378 raw: &mut Deserializer<R>,
379 _read_len: &mut CBORReadLen,
380 len: cbor_event::LenSz,
381 ) -> Result<Self, DeserializeError> {
382 let len_encoding = len.into();
383 (|| -> Result<_, DeserializeError> {
384 let tag_encoding = (|| -> Result<_, DeserializeError> {
385 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
386 if tag_value != 2 {
387 return Err(DeserializeFailure::FixedValueMismatch {
388 found: Key::Uint(tag_value),
389 expected: Key::Uint(2),
390 }
391 .into());
392 }
393 Ok(Some(tag_encoding))
394 })()
395 .map_err(|e| e.annotate("tag"))?;
396 let (multisig_scripts, multisig_scripts_encoding) =
397 (|| -> Result<_, DeserializeError> {
398 let mut multisig_scripts_arr = Vec::new();
399 let len = raw.array_sz()?;
400 let multisig_scripts_encoding = len.into();
401 while match len {
402 cbor_event::LenSz::Len(n, _) => (multisig_scripts_arr.len() as u64) < n,
403 cbor_event::LenSz::Indefinite => true,
404 } {
405 if raw.cbor_type()? == cbor_event::Type::Special {
406 assert_eq!(raw.special()?, cbor_event::Special::Break);
407 break;
408 }
409 multisig_scripts_arr.push(MultisigScript::deserialize(raw)?);
410 }
411 Ok((multisig_scripts_arr, multisig_scripts_encoding))
412 })()
413 .map_err(|e| e.annotate("multisig_scripts"))?;
414 Ok(MultisigAny {
415 multisig_scripts,
416 encodings: Some(MultisigAnyEncoding {
417 len_encoding,
418 tag_encoding,
419 multisig_scripts_encoding,
420 }),
421 })
422 })()
423 .map_err(|e| e.annotate("MultisigAny"))
424 }
425}
426
427impl Serialize for MultisigNOfK {
428 fn serialize<'se, W: Write>(
429 &self,
430 serializer: &'se mut Serializer<W>,
431 force_canonical: bool,
432 ) -> cbor_event::Result<&'se mut Serializer<W>> {
433 serializer.write_array_sz(
434 self.encodings
435 .as_ref()
436 .map(|encs| encs.len_encoding)
437 .unwrap_or_default()
438 .to_len_sz(3, force_canonical),
439 )?;
440 self.serialize_as_embedded_group(serializer, force_canonical)
441 }
442}
443
444impl SerializeEmbeddedGroup for MultisigNOfK {
445 fn serialize_as_embedded_group<'se, W: Write>(
446 &self,
447 serializer: &'se mut Serializer<W>,
448 force_canonical: bool,
449 ) -> cbor_event::Result<&'se mut Serializer<W>> {
450 serializer.write_unsigned_integer_sz(
451 3u64,
452 fit_sz(
453 3u64,
454 self.encodings
455 .as_ref()
456 .map(|encs| encs.tag_encoding)
457 .unwrap_or_default(),
458 force_canonical,
459 ),
460 )?;
461 serializer.write_unsigned_integer_sz(
462 self.n,
463 fit_sz(
464 self.n,
465 self.encodings
466 .as_ref()
467 .map(|encs| encs.n_encoding)
468 .unwrap_or_default(),
469 force_canonical,
470 ),
471 )?;
472 serializer.write_array_sz(
473 self.encodings
474 .as_ref()
475 .map(|encs| encs.multisig_scripts_encoding)
476 .unwrap_or_default()
477 .to_len_sz(self.multisig_scripts.len() as u64, force_canonical),
478 )?;
479 for element in self.multisig_scripts.iter() {
480 element.serialize(serializer, force_canonical)?;
481 }
482 self.encodings
483 .as_ref()
484 .map(|encs| encs.multisig_scripts_encoding)
485 .unwrap_or_default()
486 .end(serializer, force_canonical)?;
487 self.encodings
488 .as_ref()
489 .map(|encs| encs.len_encoding)
490 .unwrap_or_default()
491 .end(serializer, force_canonical)
492 }
493}
494
495impl Deserialize for MultisigNOfK {
496 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
497 let len = raw.array_sz()?;
498 let mut read_len = CBORReadLen::new(len);
499 read_len.read_elems(3)?;
500 read_len.finish()?;
501 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
502 match len {
503 cbor_event::LenSz::Len(_, _) => (),
504 cbor_event::LenSz::Indefinite => match raw.special()? {
505 cbor_event::Special::Break => (),
506 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
507 },
508 }
509 ret
510 }
511}
512
513impl DeserializeEmbeddedGroup for MultisigNOfK {
514 fn deserialize_as_embedded_group<R: BufRead + Seek>(
515 raw: &mut Deserializer<R>,
516 _read_len: &mut CBORReadLen,
517 len: cbor_event::LenSz,
518 ) -> Result<Self, DeserializeError> {
519 let len_encoding = len.into();
520 (|| -> Result<_, DeserializeError> {
521 let tag_encoding = (|| -> Result<_, DeserializeError> {
522 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
523 if tag_value != 3 {
524 return Err(DeserializeFailure::FixedValueMismatch {
525 found: Key::Uint(tag_value),
526 expected: Key::Uint(3),
527 }
528 .into());
529 }
530 Ok(Some(tag_encoding))
531 })()
532 .map_err(|e| e.annotate("tag"))?;
533 let (n, n_encoding) = raw
534 .unsigned_integer_sz()
535 .map_err(Into::<DeserializeError>::into)
536 .map(|(x, enc)| (x, Some(enc)))
537 .map_err(|e: DeserializeError| e.annotate("n"))?;
538 let (multisig_scripts, multisig_scripts_encoding) =
539 (|| -> Result<_, DeserializeError> {
540 let mut multisig_scripts_arr = Vec::new();
541 let len = raw.array_sz()?;
542 let multisig_scripts_encoding = len.into();
543 while match len {
544 cbor_event::LenSz::Len(n, _) => (multisig_scripts_arr.len() as u64) < n,
545 cbor_event::LenSz::Indefinite => true,
546 } {
547 if raw.cbor_type()? == cbor_event::Type::Special {
548 assert_eq!(raw.special()?, cbor_event::Special::Break);
549 break;
550 }
551 multisig_scripts_arr.push(MultisigScript::deserialize(raw)?);
552 }
553 Ok((multisig_scripts_arr, multisig_scripts_encoding))
554 })()
555 .map_err(|e| e.annotate("multisig_scripts"))?;
556 Ok(MultisigNOfK {
557 n,
558 multisig_scripts,
559 encodings: Some(MultisigNOfKEncoding {
560 len_encoding,
561 tag_encoding,
562 n_encoding,
563 multisig_scripts_encoding,
564 }),
565 })
566 })()
567 .map_err(|e| e.annotate("MultisigNOfK"))
568 }
569}
570
571impl Serialize for MultisigPubkey {
572 fn serialize<'se, W: Write>(
573 &self,
574 serializer: &'se mut Serializer<W>,
575 force_canonical: bool,
576 ) -> cbor_event::Result<&'se mut Serializer<W>> {
577 serializer.write_array_sz(
578 self.encodings
579 .as_ref()
580 .map(|encs| encs.len_encoding)
581 .unwrap_or_default()
582 .to_len_sz(2, force_canonical),
583 )?;
584 self.serialize_as_embedded_group(serializer, force_canonical)
585 }
586}
587
588impl SerializeEmbeddedGroup for MultisigPubkey {
589 fn serialize_as_embedded_group<'se, W: Write>(
590 &self,
591 serializer: &'se mut Serializer<W>,
592 force_canonical: bool,
593 ) -> cbor_event::Result<&'se mut Serializer<W>> {
594 serializer.write_unsigned_integer_sz(
595 0u64,
596 fit_sz(
597 0u64,
598 self.encodings
599 .as_ref()
600 .map(|encs| encs.tag_encoding)
601 .unwrap_or_default(),
602 force_canonical,
603 ),
604 )?;
605 serializer.write_bytes_sz(
606 self.ed25519_key_hash.to_raw_bytes(),
607 self.encodings
608 .as_ref()
609 .map(|encs| encs.ed25519_key_hash_encoding.clone())
610 .unwrap_or_default()
611 .to_str_len_sz(
612 self.ed25519_key_hash.to_raw_bytes().len() as u64,
613 force_canonical,
614 ),
615 )?;
616 self.encodings
617 .as_ref()
618 .map(|encs| encs.len_encoding)
619 .unwrap_or_default()
620 .end(serializer, force_canonical)
621 }
622}
623
624impl Deserialize for MultisigPubkey {
625 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
626 let len = raw.array_sz()?;
627 let mut read_len = CBORReadLen::new(len);
628 read_len.read_elems(2)?;
629 read_len.finish()?;
630 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
631 match len {
632 cbor_event::LenSz::Len(_, _) => (),
633 cbor_event::LenSz::Indefinite => match raw.special()? {
634 cbor_event::Special::Break => (),
635 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
636 },
637 }
638 ret
639 }
640}
641
642impl DeserializeEmbeddedGroup for MultisigPubkey {
643 fn deserialize_as_embedded_group<R: BufRead + Seek>(
644 raw: &mut Deserializer<R>,
645 _read_len: &mut CBORReadLen,
646 len: cbor_event::LenSz,
647 ) -> Result<Self, DeserializeError> {
648 let len_encoding = len.into();
649 (|| -> Result<_, DeserializeError> {
650 let tag_encoding = (|| -> Result<_, DeserializeError> {
651 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
652 if tag_value != 0 {
653 return Err(DeserializeFailure::FixedValueMismatch {
654 found: Key::Uint(tag_value),
655 expected: Key::Uint(0),
656 }
657 .into());
658 }
659 Ok(Some(tag_encoding))
660 })()
661 .map_err(|e| e.annotate("tag"))?;
662 let (ed25519_key_hash, ed25519_key_hash_encoding) = raw
663 .bytes_sz()
664 .map_err(Into::<DeserializeError>::into)
665 .and_then(|(bytes, enc)| {
666 Ed25519KeyHash::from_raw_bytes(&bytes)
667 .map(|bytes| (bytes, StringEncoding::from(enc)))
668 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
669 })
670 .map_err(|e: DeserializeError| e.annotate("ed25519_key_hash"))?;
671 Ok(MultisigPubkey {
672 ed25519_key_hash,
673 encodings: Some(MultisigPubkeyEncoding {
674 len_encoding,
675 tag_encoding,
676 ed25519_key_hash_encoding,
677 }),
678 })
679 })()
680 .map_err(|e| e.annotate("MultisigPubkey"))
681 }
682}
683
684impl Serialize for MultisigScript {
685 fn serialize<'se, W: Write>(
686 &self,
687 serializer: &'se mut Serializer<W>,
688 force_canonical: bool,
689 ) -> cbor_event::Result<&'se mut Serializer<W>> {
690 match self {
691 MultisigScript::MultisigPubkey(multisig_pubkey) => {
692 multisig_pubkey.serialize(serializer, force_canonical)
693 }
694 MultisigScript::MultisigAll(multisig_all) => {
695 multisig_all.serialize(serializer, force_canonical)
696 }
697 MultisigScript::MultisigAny(multisig_any) => {
698 multisig_any.serialize(serializer, force_canonical)
699 }
700 MultisigScript::MultisigNOfK(multisig_n_of_k) => {
701 multisig_n_of_k.serialize(serializer, force_canonical)
702 }
703 }
704 }
705}
706
707impl Deserialize for MultisigScript {
708 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
709 (|| -> Result<_, DeserializeError> {
710 let len = raw.array_sz()?;
711 let initial_position = raw.as_mut_ref().stream_position().unwrap();
712 let mut errs = Vec::new();
713 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
714 let mut read_len = CBORReadLen::new(len);
715 read_len.read_elems(2)?;
716 read_len.finish()?;
717 let ret = MultisigPubkey::deserialize_as_embedded_group(raw, &mut read_len, len);
718 match len {
719 cbor_event::LenSz::Len(_, _) => (),
720 cbor_event::LenSz::Indefinite => match raw.special()? {
721 cbor_event::Special::Break => (),
722 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
723 },
724 }
725 ret
726 })(raw);
727 match deser_variant {
728 Ok(multisig_pubkey) => return Ok(Self::MultisigPubkey(multisig_pubkey)),
729 Err(e) => {
730 errs.push(e.annotate("MultisigPubkey"));
731 raw.as_mut_ref()
732 .seek(SeekFrom::Start(initial_position))
733 .unwrap();
734 }
735 };
736 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
737 let mut read_len = CBORReadLen::new(len);
738 read_len.read_elems(2)?;
739 read_len.finish()?;
740 let ret = MultisigAll::deserialize_as_embedded_group(raw, &mut read_len, len);
741 match len {
742 cbor_event::LenSz::Len(_, _) => (),
743 cbor_event::LenSz::Indefinite => match raw.special()? {
744 cbor_event::Special::Break => (),
745 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
746 },
747 }
748 ret
749 })(raw);
750 match deser_variant {
751 Ok(multisig_all) => return Ok(Self::MultisigAll(multisig_all)),
752 Err(e) => {
753 errs.push(e.annotate("MultisigAll"));
754 raw.as_mut_ref()
755 .seek(SeekFrom::Start(initial_position))
756 .unwrap();
757 }
758 };
759 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
760 let mut read_len = CBORReadLen::new(len);
761 read_len.read_elems(2)?;
762 read_len.finish()?;
763 let ret = MultisigAny::deserialize_as_embedded_group(raw, &mut read_len, len);
764 match len {
765 cbor_event::LenSz::Len(_, _) => (),
766 cbor_event::LenSz::Indefinite => match raw.special()? {
767 cbor_event::Special::Break => (),
768 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
769 },
770 }
771 ret
772 })(raw);
773 match deser_variant {
774 Ok(multisig_any) => return Ok(Self::MultisigAny(multisig_any)),
775 Err(e) => {
776 errs.push(e.annotate("MultisigAny"));
777 raw.as_mut_ref()
778 .seek(SeekFrom::Start(initial_position))
779 .unwrap();
780 }
781 };
782 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
783 let mut read_len = CBORReadLen::new(len);
784 read_len.read_elems(3)?;
785 read_len.finish()?;
786 let ret = MultisigNOfK::deserialize_as_embedded_group(raw, &mut read_len, len);
787 match len {
788 cbor_event::LenSz::Len(_, _) => (),
789 cbor_event::LenSz::Indefinite => match raw.special()? {
790 cbor_event::Special::Break => (),
791 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
792 },
793 }
794 ret
795 })(raw);
796 match deser_variant {
797 Ok(multisig_n_of_k) => return Ok(Self::MultisigNOfK(multisig_n_of_k)),
798 Err(e) => {
799 errs.push(e.annotate("MultisigNOfK"));
800 raw.as_mut_ref()
801 .seek(SeekFrom::Start(initial_position))
802 .unwrap();
803 }
804 };
805 Err(DeserializeError::new(
806 "MultisigScript",
807 DeserializeFailure::NoVariantMatchedWithCauses(errs),
808 ))
809 })()
810 .map_err(|e| e.annotate("MultisigScript"))
811 }
812}
813
814impl Serialize for ProtocolVersionStruct {
815 fn serialize<'se, W: Write>(
816 &self,
817 serializer: &'se mut Serializer<W>,
818 force_canonical: bool,
819 ) -> cbor_event::Result<&'se mut Serializer<W>> {
820 serializer.write_array_sz(
821 self.encodings
822 .as_ref()
823 .map(|encs| encs.len_encoding)
824 .unwrap_or_default()
825 .to_len_sz(2, force_canonical),
826 )?;
827 self.protocol_version
828 .serialize_as_embedded_group(serializer, force_canonical)?;
829 self.encodings
830 .as_ref()
831 .map(|encs| encs.len_encoding)
832 .unwrap_or_default()
833 .end(serializer, force_canonical)
834 }
835}
836
837impl Deserialize for ProtocolVersionStruct {
838 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
839 let len = raw.array_sz()?;
840 let len_encoding: LenEncoding = len.into();
841 let mut read_len = CBORReadLen::new(len);
842 read_len.read_elems(2)?;
843 read_len.finish()?;
844 (|| -> Result<_, DeserializeError> {
845 let protocol_version =
846 ProtocolVersion::deserialize_as_embedded_group(raw, &mut read_len, len)
847 .map_err(|e: DeserializeError| e.annotate("protocol_version"))?;
848 match len {
849 cbor_event::LenSz::Len(_, _) => (),
850 cbor_event::LenSz::Indefinite => match raw.special()? {
851 cbor_event::Special::Break => (),
852 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
853 },
854 }
855 Ok(ProtocolVersionStruct {
856 protocol_version,
857 encodings: Some(ProtocolVersionStructEncoding { len_encoding }),
858 })
859 })()
860 .map_err(|e| e.annotate("ProtocolVersionStruct"))
861 }
862}
863
864impl Serialize for ShelleyBlock {
865 fn serialize<'se, W: Write>(
866 &self,
867 serializer: &'se mut Serializer<W>,
868 force_canonical: bool,
869 ) -> cbor_event::Result<&'se mut Serializer<W>> {
870 serializer.write_array_sz(
871 self.encodings
872 .as_ref()
873 .map(|encs| encs.len_encoding)
874 .unwrap_or_default()
875 .to_len_sz(4, force_canonical),
876 )?;
877 self.header.serialize(serializer, force_canonical)?;
878 serializer.write_array_sz(
879 self.encodings
880 .as_ref()
881 .map(|encs| encs.transaction_bodies_encoding)
882 .unwrap_or_default()
883 .to_len_sz(self.transaction_bodies.len() as u64, force_canonical),
884 )?;
885 for element in self.transaction_bodies.iter() {
886 element.serialize(serializer, force_canonical)?;
887 }
888 self.encodings
889 .as_ref()
890 .map(|encs| encs.transaction_bodies_encoding)
891 .unwrap_or_default()
892 .end(serializer, force_canonical)?;
893 serializer.write_array_sz(
894 self.encodings
895 .as_ref()
896 .map(|encs| encs.transaction_witness_sets_encoding)
897 .unwrap_or_default()
898 .to_len_sz(self.transaction_witness_sets.len() as u64, force_canonical),
899 )?;
900 for element in self.transaction_witness_sets.iter() {
901 element.serialize(serializer, force_canonical)?;
902 }
903 self.encodings
904 .as_ref()
905 .map(|encs| encs.transaction_witness_sets_encoding)
906 .unwrap_or_default()
907 .end(serializer, force_canonical)?;
908 serializer.write_map_sz(
909 self.encodings
910 .as_ref()
911 .map(|encs| encs.transaction_metadata_set_encoding)
912 .unwrap_or_default()
913 .to_len_sz(self.transaction_metadata_set.len() as u64, force_canonical),
914 )?;
915 let mut key_order = self
916 .transaction_metadata_set
917 .iter()
918 .map(|(k, v)| {
919 let mut buf = cbor_event::se::Serializer::new_vec();
920 let transaction_metadata_set_key_encoding = self
921 .encodings
922 .as_ref()
923 .and_then(|encs| encs.transaction_metadata_set_key_encodings.get(k))
924 .cloned()
925 .unwrap_or_default();
926 buf.write_unsigned_integer_sz(
927 *k as u64,
928 fit_sz(
929 *k as u64,
930 transaction_metadata_set_key_encoding,
931 force_canonical,
932 ),
933 )?;
934 Ok((buf.finalize(), k, v))
935 })
936 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
937 if force_canonical {
938 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
939 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
940 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
941 diff_ord => diff_ord,
942 }
943 });
944 }
945 for (key_bytes, _key, value) in key_order {
946 serializer.write_raw_bytes(&key_bytes)?;
947 value.serialize(serializer, force_canonical)?;
948 }
949 self.encodings
950 .as_ref()
951 .map(|encs| encs.transaction_metadata_set_encoding)
952 .unwrap_or_default()
953 .end(serializer, force_canonical)?;
954 self.encodings
955 .as_ref()
956 .map(|encs| encs.len_encoding)
957 .unwrap_or_default()
958 .end(serializer, force_canonical)
959 }
960}
961
962impl Deserialize for ShelleyBlock {
963 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
964 let len = raw.array_sz()?;
965 let len_encoding: LenEncoding = len.into();
966 let mut read_len = CBORReadLen::new(len);
967 read_len.read_elems(4)?;
968 read_len.finish()?;
969 (|| -> Result<_, DeserializeError> {
970 let header = ShelleyHeader::deserialize(raw)
971 .map_err(|e: DeserializeError| e.annotate("header"))?;
972 let (transaction_bodies, transaction_bodies_encoding) =
973 (|| -> Result<_, DeserializeError> {
974 let mut transaction_bodies_arr = Vec::new();
975 let len = raw.array_sz()?;
976 let transaction_bodies_encoding = len.into();
977 while match len {
978 cbor_event::LenSz::Len(n, _) => (transaction_bodies_arr.len() as u64) < n,
979 cbor_event::LenSz::Indefinite => true,
980 } {
981 if raw.cbor_type()? == cbor_event::Type::Special {
982 assert_eq!(raw.special()?, cbor_event::Special::Break);
983 break;
984 }
985 transaction_bodies_arr.push(ShelleyTransactionBody::deserialize(raw)?);
986 }
987 Ok((transaction_bodies_arr, transaction_bodies_encoding))
988 })()
989 .map_err(|e| e.annotate("transaction_bodies"))?;
990 let (transaction_witness_sets, transaction_witness_sets_encoding) =
991 (|| -> Result<_, DeserializeError> {
992 let mut transaction_witness_sets_arr = Vec::new();
993 let len = raw.array_sz()?;
994 let transaction_witness_sets_encoding = len.into();
995 while match len {
996 cbor_event::LenSz::Len(n, _) => {
997 (transaction_witness_sets_arr.len() as u64) < n
998 }
999 cbor_event::LenSz::Indefinite => true,
1000 } {
1001 if raw.cbor_type()? == cbor_event::Type::Special {
1002 assert_eq!(raw.special()?, cbor_event::Special::Break);
1003 break;
1004 }
1005 transaction_witness_sets_arr
1006 .push(ShelleyTransactionWitnessSet::deserialize(raw)?);
1007 }
1008 Ok((
1009 transaction_witness_sets_arr,
1010 transaction_witness_sets_encoding,
1011 ))
1012 })()
1013 .map_err(|e| e.annotate("transaction_witness_sets"))?;
1014 let (
1015 transaction_metadata_set,
1016 transaction_metadata_set_encoding,
1017 transaction_metadata_set_key_encodings,
1018 ) = (|| -> Result<_, DeserializeError> {
1019 let mut transaction_metadata_set_table = OrderedHashMap::new();
1020 let transaction_metadata_set_len = raw.map_sz()?;
1021 let transaction_metadata_set_encoding = transaction_metadata_set_len.into();
1022 let mut transaction_metadata_set_key_encodings = BTreeMap::new();
1023 while match transaction_metadata_set_len {
1024 cbor_event::LenSz::Len(n, _) => {
1025 (transaction_metadata_set_table.len() as u64) < n
1026 }
1027 cbor_event::LenSz::Indefinite => true,
1028 } {
1029 if raw.cbor_type()? == cbor_event::Type::Special {
1030 assert_eq!(raw.special()?, cbor_event::Special::Break);
1031 break;
1032 }
1033 let (transaction_metadata_set_key, transaction_metadata_set_key_encoding) = raw
1034 .unsigned_integer_sz()
1035 .map(|(x, enc)| (x as u16, Some(enc)))?;
1036 let transaction_metadata_set_value = Metadata::deserialize(raw)?;
1037 if transaction_metadata_set_table
1038 .insert(transaction_metadata_set_key, transaction_metadata_set_value)
1039 .is_some()
1040 {
1041 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1042 "some complicated/unsupported type",
1043 )))
1044 .into());
1045 }
1046 transaction_metadata_set_key_encodings.insert(
1047 transaction_metadata_set_key,
1048 transaction_metadata_set_key_encoding,
1049 );
1050 }
1051 Ok((
1052 transaction_metadata_set_table,
1053 transaction_metadata_set_encoding,
1054 transaction_metadata_set_key_encodings,
1055 ))
1056 })()
1057 .map_err(|e| e.annotate("transaction_metadata_set"))?;
1058 match len {
1059 cbor_event::LenSz::Len(_, _) => (),
1060 cbor_event::LenSz::Indefinite => match raw.special()? {
1061 cbor_event::Special::Break => (),
1062 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1063 },
1064 }
1065 Ok(ShelleyBlock {
1066 header,
1067 transaction_bodies,
1068 transaction_witness_sets,
1069 transaction_metadata_set,
1070 encodings: Some(ShelleyBlockEncoding {
1071 len_encoding,
1072 transaction_bodies_encoding,
1073 transaction_witness_sets_encoding,
1074 transaction_metadata_set_encoding,
1075 transaction_metadata_set_key_encodings,
1076 }),
1077 })
1078 })()
1079 .map_err(|e| e.annotate("ShelleyBlock"))
1080 }
1081}
1082
1083impl Serialize for ShelleyCertificate {
1084 fn serialize<'se, W: Write>(
1085 &self,
1086 serializer: &'se mut Serializer<W>,
1087 force_canonical: bool,
1088 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1089 match self {
1090 ShelleyCertificate::StakeRegistration(stake_registration) => {
1091 stake_registration.serialize(serializer, force_canonical)
1092 }
1093 ShelleyCertificate::StakeDeregistration(stake_deregistration) => {
1094 stake_deregistration.serialize(serializer, force_canonical)
1095 }
1096 ShelleyCertificate::StakeDelegation(stake_delegation) => {
1097 stake_delegation.serialize(serializer, force_canonical)
1098 }
1099 ShelleyCertificate::ShelleyPoolRegistration(shelley_pool_registration) => {
1100 shelley_pool_registration.serialize(serializer, force_canonical)
1101 }
1102 ShelleyCertificate::PoolRetirement(pool_retirement) => {
1103 pool_retirement.serialize(serializer, force_canonical)
1104 }
1105 ShelleyCertificate::GenesisKeyDelegation(genesis_key_delegation) => {
1106 genesis_key_delegation.serialize(serializer, force_canonical)
1107 }
1108 ShelleyCertificate::ShelleyMoveInstantaneousRewardsCert(
1109 shelley_move_instantaneous_rewards_cert,
1110 ) => shelley_move_instantaneous_rewards_cert.serialize(serializer, force_canonical),
1111 }
1112 }
1113}
1114
1115impl Deserialize for ShelleyCertificate {
1116 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1117 (|| -> Result<_, DeserializeError> {
1118 let len = raw.array_sz()?;
1119 let initial_position = raw.as_mut_ref().stream_position().unwrap();
1120 let mut errs = Vec::new();
1121 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1122 let mut read_len = CBORReadLen::new(len);
1123 read_len.read_elems(2)?;
1124 read_len.finish()?;
1125 let ret = StakeRegistration::deserialize_as_embedded_group(raw, &mut read_len, len);
1126 match len {
1127 cbor_event::LenSz::Len(_, _) => (),
1128 cbor_event::LenSz::Indefinite => match raw.special()? {
1129 cbor_event::Special::Break => (),
1130 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1131 },
1132 }
1133 ret
1134 })(raw);
1135 match deser_variant {
1136 Ok(stake_registration) => return Ok(Self::StakeRegistration(stake_registration)),
1137 Err(e) => {
1138 errs.push(e.annotate("StakeRegistration"));
1139 raw.as_mut_ref()
1140 .seek(SeekFrom::Start(initial_position))
1141 .unwrap();
1142 }
1143 };
1144 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1145 let mut read_len = CBORReadLen::new(len);
1146 read_len.read_elems(2)?;
1147 read_len.finish()?;
1148 let ret =
1149 StakeDeregistration::deserialize_as_embedded_group(raw, &mut read_len, len);
1150 match len {
1151 cbor_event::LenSz::Len(_, _) => (),
1152 cbor_event::LenSz::Indefinite => match raw.special()? {
1153 cbor_event::Special::Break => (),
1154 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1155 },
1156 }
1157 ret
1158 })(raw);
1159 match deser_variant {
1160 Ok(stake_deregistration) => {
1161 return Ok(Self::StakeDeregistration(stake_deregistration))
1162 }
1163 Err(e) => {
1164 errs.push(e.annotate("StakeDeregistration"));
1165 raw.as_mut_ref()
1166 .seek(SeekFrom::Start(initial_position))
1167 .unwrap();
1168 }
1169 };
1170 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1171 let mut read_len = CBORReadLen::new(len);
1172 read_len.read_elems(3)?;
1173 read_len.finish()?;
1174 let ret = StakeDelegation::deserialize_as_embedded_group(raw, &mut read_len, len);
1175 match len {
1176 cbor_event::LenSz::Len(_, _) => (),
1177 cbor_event::LenSz::Indefinite => match raw.special()? {
1178 cbor_event::Special::Break => (),
1179 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1180 },
1181 }
1182 ret
1183 })(raw);
1184 match deser_variant {
1185 Ok(stake_delegation) => return Ok(Self::StakeDelegation(stake_delegation)),
1186 Err(e) => {
1187 errs.push(e.annotate("StakeDelegation"));
1188 raw.as_mut_ref()
1189 .seek(SeekFrom::Start(initial_position))
1190 .unwrap();
1191 }
1192 };
1193 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1194 let mut read_len = CBORReadLen::new(len);
1195 read_len.read_elems(10)?;
1196 read_len.finish()?;
1197 let ret =
1198 ShelleyPoolRegistration::deserialize_as_embedded_group(raw, &mut read_len, len);
1199 match len {
1200 cbor_event::LenSz::Len(_, _) => (),
1201 cbor_event::LenSz::Indefinite => match raw.special()? {
1202 cbor_event::Special::Break => (),
1203 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1204 },
1205 }
1206 ret
1207 })(raw);
1208 match deser_variant {
1209 Ok(shelley_pool_registration) => {
1210 return Ok(Self::ShelleyPoolRegistration(shelley_pool_registration))
1211 }
1212 Err(e) => {
1213 errs.push(e.annotate("ShelleyPoolRegistration"));
1214 raw.as_mut_ref()
1215 .seek(SeekFrom::Start(initial_position))
1216 .unwrap();
1217 }
1218 };
1219 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1220 let mut read_len = CBORReadLen::new(len);
1221 read_len.read_elems(3)?;
1222 read_len.finish()?;
1223 let ret = PoolRetirement::deserialize_as_embedded_group(raw, &mut read_len, len);
1224 match len {
1225 cbor_event::LenSz::Len(_, _) => (),
1226 cbor_event::LenSz::Indefinite => match raw.special()? {
1227 cbor_event::Special::Break => (),
1228 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1229 },
1230 }
1231 ret
1232 })(raw);
1233 match deser_variant {
1234 Ok(pool_retirement) => return Ok(Self::PoolRetirement(pool_retirement)),
1235 Err(e) => {
1236 errs.push(e.annotate("PoolRetirement"));
1237 raw.as_mut_ref()
1238 .seek(SeekFrom::Start(initial_position))
1239 .unwrap();
1240 }
1241 };
1242 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1243 let mut read_len = CBORReadLen::new(len);
1244 read_len.read_elems(4)?;
1245 read_len.finish()?;
1246 let ret =
1247 GenesisKeyDelegation::deserialize_as_embedded_group(raw, &mut read_len, len);
1248 match len {
1249 cbor_event::LenSz::Len(_, _) => (),
1250 cbor_event::LenSz::Indefinite => match raw.special()? {
1251 cbor_event::Special::Break => (),
1252 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1253 },
1254 }
1255 ret
1256 })(raw);
1257 match deser_variant {
1258 Ok(genesis_key_delegation) => {
1259 return Ok(Self::GenesisKeyDelegation(genesis_key_delegation))
1260 }
1261 Err(e) => {
1262 errs.push(e.annotate("GenesisKeyDelegation"));
1263 raw.as_mut_ref()
1264 .seek(SeekFrom::Start(initial_position))
1265 .unwrap();
1266 }
1267 };
1268 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1269 let mut read_len = CBORReadLen::new(len);
1270 read_len.read_elems(2)?;
1271 read_len.finish()?;
1272 let ret = ShelleyMoveInstantaneousRewardsCert::deserialize_as_embedded_group(
1273 raw,
1274 &mut read_len,
1275 len,
1276 );
1277 match len {
1278 cbor_event::LenSz::Len(_, _) => (),
1279 cbor_event::LenSz::Indefinite => match raw.special()? {
1280 cbor_event::Special::Break => (),
1281 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1282 },
1283 }
1284 ret
1285 })(raw);
1286 match deser_variant {
1287 Ok(shelley_move_instantaneous_rewards_cert) => {
1288 return Ok(Self::ShelleyMoveInstantaneousRewardsCert(
1289 shelley_move_instantaneous_rewards_cert,
1290 ))
1291 }
1292 Err(e) => {
1293 errs.push(e.annotate("ShelleyMoveInstantaneousRewardsCert"));
1294 raw.as_mut_ref()
1295 .seek(SeekFrom::Start(initial_position))
1296 .unwrap();
1297 }
1298 };
1299 Err(DeserializeError::new(
1300 "ShelleyCertificate",
1301 DeserializeFailure::NoVariantMatchedWithCauses(errs),
1302 ))
1303 })()
1304 .map_err(|e| e.annotate("ShelleyCertificate"))
1305 }
1306}
1307
1308impl Serialize for ShelleyDNSName {
1309 fn serialize<'se, W: Write>(
1310 &self,
1311 serializer: &'se mut Serializer<W>,
1312 force_canonical: bool,
1313 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1314 serializer.write_text_sz(
1315 &self.inner,
1316 self.encodings
1317 .as_ref()
1318 .map(|encs| encs.inner_encoding.clone())
1319 .unwrap_or_default()
1320 .to_str_len_sz(self.inner.len() as u64, force_canonical),
1321 )
1322 }
1323}
1324
1325impl Deserialize for ShelleyDNSName {
1326 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1327 let (inner, inner_encoding) = raw
1328 .text_sz()
1329 .map(|(s, enc)| (s, StringEncoding::from(enc)))?;
1330 if inner.len() > 64 {
1331 return Err(DeserializeError::new(
1332 "ShelleyDNSName",
1333 DeserializeFailure::RangeCheck {
1334 found: inner.len() as isize,
1335 min: Some(0),
1336 max: Some(64),
1337 },
1338 ));
1339 }
1340 Ok(Self {
1341 inner,
1342 encodings: Some(ShelleyDNSNameEncoding { inner_encoding }),
1343 })
1344 }
1345}
1346
1347impl Serialize for ShelleyHeader {
1348 fn serialize<'se, W: Write>(
1349 &self,
1350 serializer: &'se mut Serializer<W>,
1351 force_canonical: bool,
1352 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1353 serializer.write_array_sz(
1354 self.encodings
1355 .as_ref()
1356 .map(|encs| encs.len_encoding)
1357 .unwrap_or_default()
1358 .to_len_sz(2, force_canonical),
1359 )?;
1360 self.body.serialize(serializer, force_canonical)?;
1361 self.signature.serialize(serializer, force_canonical)?;
1362 self.encodings
1363 .as_ref()
1364 .map(|encs| encs.len_encoding)
1365 .unwrap_or_default()
1366 .end(serializer, force_canonical)
1367 }
1368}
1369
1370impl Deserialize for ShelleyHeader {
1371 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1372 let len = raw.array_sz()?;
1373 let len_encoding: LenEncoding = len.into();
1374 let mut read_len = CBORReadLen::new(len);
1375 read_len.read_elems(2)?;
1376 read_len.finish()?;
1377 (|| -> Result<_, DeserializeError> {
1378 let body = ShelleyHeaderBody::deserialize(raw)
1379 .map_err(|e: DeserializeError| e.annotate("body"))?;
1380 let signature = KESSignature::deserialize(raw)
1381 .map_err(|e: DeserializeError| e.annotate("signature"))?;
1382 match len {
1383 cbor_event::LenSz::Len(_, _) => (),
1384 cbor_event::LenSz::Indefinite => match raw.special()? {
1385 cbor_event::Special::Break => (),
1386 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1387 },
1388 }
1389 Ok(ShelleyHeader {
1390 body,
1391 signature,
1392 encodings: Some(ShelleyHeaderEncoding { len_encoding }),
1393 })
1394 })()
1395 .map_err(|e| e.annotate("ShelleyHeader"))
1396 }
1397}
1398
1399impl Serialize for ShelleyHeaderBody {
1400 fn serialize<'se, W: Write>(
1401 &self,
1402 serializer: &'se mut Serializer<W>,
1403 force_canonical: bool,
1404 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1405 serializer.write_array_sz(
1406 self.encodings
1407 .as_ref()
1408 .map(|encs| encs.len_encoding)
1409 .unwrap_or_default()
1410 .to_len_sz(15, force_canonical),
1411 )?;
1412 serializer.write_unsigned_integer_sz(
1413 self.block_number,
1414 fit_sz(
1415 self.block_number,
1416 self.encodings
1417 .as_ref()
1418 .map(|encs| encs.block_number_encoding)
1419 .unwrap_or_default(),
1420 force_canonical,
1421 ),
1422 )?;
1423 serializer.write_unsigned_integer_sz(
1424 self.slot,
1425 fit_sz(
1426 self.slot,
1427 self.encodings
1428 .as_ref()
1429 .map(|encs| encs.slot_encoding)
1430 .unwrap_or_default(),
1431 force_canonical,
1432 ),
1433 )?;
1434 match &self.prev_hash {
1435 Some(x) => serializer.write_bytes_sz(
1436 x.to_raw_bytes(),
1437 self.encodings
1438 .as_ref()
1439 .map(|encs| encs.prev_hash_encoding.clone())
1440 .unwrap_or_default()
1441 .to_str_len_sz(x.to_raw_bytes().len() as u64, force_canonical),
1442 ),
1443 None => serializer.write_special(cbor_event::Special::Null),
1444 }?;
1445 serializer.write_bytes_sz(
1446 self.issuer_vkey.to_raw_bytes(),
1447 self.encodings
1448 .as_ref()
1449 .map(|encs| encs.issuer_vkey_encoding.clone())
1450 .unwrap_or_default()
1451 .to_str_len_sz(
1452 self.issuer_vkey.to_raw_bytes().len() as u64,
1453 force_canonical,
1454 ),
1455 )?;
1456 serializer.write_bytes_sz(
1457 self.vrf_vkey.to_raw_bytes(),
1458 self.encodings
1459 .as_ref()
1460 .map(|encs| encs.vrf_vkey_encoding.clone())
1461 .unwrap_or_default()
1462 .to_str_len_sz(self.vrf_vkey.to_raw_bytes().len() as u64, force_canonical),
1463 )?;
1464 self.nonce_vrf.serialize(serializer, force_canonical)?;
1465 self.leader_vrf.serialize(serializer, force_canonical)?;
1466 serializer.write_unsigned_integer_sz(
1467 self.block_body_size,
1468 fit_sz(
1469 self.block_body_size,
1470 self.encodings
1471 .as_ref()
1472 .map(|encs| encs.block_body_size_encoding)
1473 .unwrap_or_default(),
1474 force_canonical,
1475 ),
1476 )?;
1477 serializer.write_bytes_sz(
1478 self.block_body_hash.to_raw_bytes(),
1479 self.encodings
1480 .as_ref()
1481 .map(|encs| encs.block_body_hash_encoding.clone())
1482 .unwrap_or_default()
1483 .to_str_len_sz(
1484 self.block_body_hash.to_raw_bytes().len() as u64,
1485 force_canonical,
1486 ),
1487 )?;
1488 self.operational_cert
1489 .serialize_as_embedded_group(serializer, force_canonical)?;
1490 self.protocol_version
1491 .serialize_as_embedded_group(serializer, force_canonical)?;
1492 self.encodings
1493 .as_ref()
1494 .map(|encs| encs.len_encoding)
1495 .unwrap_or_default()
1496 .end(serializer, force_canonical)
1497 }
1498}
1499
1500impl Deserialize for ShelleyHeaderBody {
1501 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1502 let len = raw.array_sz()?;
1503 let len_encoding: LenEncoding = len.into();
1504 let mut read_len = CBORReadLen::new(len);
1505 read_len.read_elems(15)?;
1506 read_len.finish()?;
1507 (|| -> Result<_, DeserializeError> {
1508 let (block_number, block_number_encoding) = raw
1509 .unsigned_integer_sz()
1510 .map_err(Into::<DeserializeError>::into)
1511 .map(|(x, enc)| (x, Some(enc)))
1512 .map_err(|e: DeserializeError| e.annotate("block_number"))?;
1513 let (slot, slot_encoding) = raw
1514 .unsigned_integer_sz()
1515 .map_err(Into::<DeserializeError>::into)
1516 .map(|(x, enc)| (x, Some(enc)))
1517 .map_err(|e: DeserializeError| e.annotate("slot"))?;
1518 let (prev_hash, prev_hash_encoding) = (|| -> Result<_, DeserializeError> {
1519 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
1520 true => Result::<_, DeserializeError>::Ok(
1521 raw.bytes_sz()
1522 .map_err(Into::<DeserializeError>::into)
1523 .and_then(|(bytes, enc)| {
1524 BlockHeaderHash::from_raw_bytes(&bytes)
1525 .map(|bytes| (bytes, StringEncoding::from(enc)))
1526 .map_err(|e| {
1527 DeserializeFailure::InvalidStructure(Box::new(e)).into()
1528 })
1529 })?,
1530 )
1531 .map(|(x, prev_hash_encoding)| (Some(x), prev_hash_encoding))?,
1532 false => {
1533 if raw.special()? != cbor_event::Special::Null {
1534 return Err(DeserializeFailure::ExpectedNull.into());
1535 }
1536 (None, StringEncoding::default())
1537 }
1538 })
1539 })()
1540 .map_err(|e| e.annotate("prev_hash"))?;
1541 let (issuer_vkey, issuer_vkey_encoding) = raw
1542 .bytes_sz()
1543 .map_err(Into::<DeserializeError>::into)
1544 .and_then(|(bytes, enc)| {
1545 Vkey::from_raw_bytes(&bytes)
1546 .map(|bytes| (bytes, StringEncoding::from(enc)))
1547 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1548 })
1549 .map_err(|e: DeserializeError| e.annotate("issuer_vkey"))?;
1550 let (vrf_vkey, vrf_vkey_encoding) = raw
1551 .bytes_sz()
1552 .map_err(Into::<DeserializeError>::into)
1553 .and_then(|(bytes, enc)| {
1554 VRFVkey::from_raw_bytes(&bytes)
1555 .map(|bytes| (bytes, StringEncoding::from(enc)))
1556 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1557 })
1558 .map_err(|e: DeserializeError| e.annotate("vrf_vkey"))?;
1559 let nonce_vrf =
1560 VRFCert::deserialize(raw).map_err(|e: DeserializeError| e.annotate("nonce_vrf"))?;
1561 let leader_vrf = VRFCert::deserialize(raw)
1562 .map_err(|e: DeserializeError| e.annotate("leader_vrf"))?;
1563 let (block_body_size, block_body_size_encoding) = raw
1564 .unsigned_integer_sz()
1565 .map_err(Into::<DeserializeError>::into)
1566 .map(|(x, enc)| (x, Some(enc)))
1567 .map_err(|e: DeserializeError| e.annotate("block_body_size"))?;
1568 let (block_body_hash, block_body_hash_encoding) = raw
1569 .bytes_sz()
1570 .map_err(Into::<DeserializeError>::into)
1571 .and_then(|(bytes, enc)| {
1572 BlockBodyHash::from_raw_bytes(&bytes)
1573 .map(|bytes| (bytes, StringEncoding::from(enc)))
1574 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1575 })
1576 .map_err(|e: DeserializeError| e.annotate("block_body_hash"))?;
1577 let operational_cert =
1578 OperationalCert::deserialize_as_embedded_group(raw, &mut read_len, len)
1579 .map_err(|e: DeserializeError| e.annotate("operational_cert"))?;
1580 let protocol_version =
1581 ProtocolVersion::deserialize_as_embedded_group(raw, &mut read_len, len)
1582 .map_err(|e: DeserializeError| e.annotate("protocol_version"))?;
1583 match len {
1584 cbor_event::LenSz::Len(_, _) => (),
1585 cbor_event::LenSz::Indefinite => match raw.special()? {
1586 cbor_event::Special::Break => (),
1587 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1588 },
1589 }
1590 Ok(ShelleyHeaderBody {
1591 block_number,
1592 slot,
1593 prev_hash,
1594 issuer_vkey,
1595 vrf_vkey,
1596 nonce_vrf,
1597 leader_vrf,
1598 block_body_size,
1599 block_body_hash,
1600 operational_cert,
1601 protocol_version,
1602 encodings: Some(ShelleyHeaderBodyEncoding {
1603 len_encoding,
1604 block_number_encoding,
1605 slot_encoding,
1606 prev_hash_encoding,
1607 issuer_vkey_encoding,
1608 vrf_vkey_encoding,
1609 block_body_size_encoding,
1610 block_body_hash_encoding,
1611 }),
1612 })
1613 })()
1614 .map_err(|e| e.annotate("ShelleyHeaderBody"))
1615 }
1616}
1617
1618impl Serialize for ShelleyMoveInstantaneousReward {
1619 fn serialize<'se, W: Write>(
1620 &self,
1621 serializer: &'se mut Serializer<W>,
1622 force_canonical: bool,
1623 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1624 serializer.write_array_sz(
1625 self.encodings
1626 .as_ref()
1627 .map(|encs| encs.len_encoding)
1628 .unwrap_or_default()
1629 .to_len_sz(2, force_canonical),
1630 )?;
1631 match &self.pot {
1632 MIRPot::Reserve => serializer.write_unsigned_integer_sz(
1633 0u64,
1634 fit_sz(
1635 0u64,
1636 self.encodings
1637 .as_ref()
1638 .map(|encs| encs.pot_encoding)
1639 .unwrap_or_default(),
1640 force_canonical,
1641 ),
1642 ),
1643 MIRPot::Treasury => serializer.write_unsigned_integer_sz(
1644 1u64,
1645 fit_sz(
1646 1u64,
1647 self.encodings
1648 .as_ref()
1649 .map(|encs| encs.pot_encoding)
1650 .unwrap_or_default(),
1651 force_canonical,
1652 ),
1653 ),
1654 }?;
1655 serializer.write_map_sz(
1656 self.encodings
1657 .as_ref()
1658 .map(|encs| encs.to_stake_credentials_encoding)
1659 .unwrap_or_default()
1660 .to_len_sz(self.to_stake_credentials.len() as u64, force_canonical),
1661 )?;
1662 let mut key_order = self
1663 .to_stake_credentials
1664 .iter()
1665 .map(|(k, v)| {
1666 let mut buf = cbor_event::se::Serializer::new_vec();
1667 k.serialize(&mut buf, force_canonical)?;
1668 Ok((buf.finalize(), k, v))
1669 })
1670 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
1671 if force_canonical {
1672 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
1673 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
1674 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
1675 diff_ord => diff_ord,
1676 }
1677 });
1678 }
1679 for (key_bytes, key, value) in key_order {
1680 serializer.write_raw_bytes(&key_bytes)?;
1681 let to_stake_credentials_value_encoding = self
1682 .encodings
1683 .as_ref()
1684 .and_then(|encs| encs.to_stake_credentials_value_encodings.get(key))
1685 .cloned()
1686 .unwrap_or_default();
1687 serializer.write_unsigned_integer_sz(
1688 *value,
1689 fit_sz(*value, to_stake_credentials_value_encoding, force_canonical),
1690 )?;
1691 }
1692 self.encodings
1693 .as_ref()
1694 .map(|encs| encs.to_stake_credentials_encoding)
1695 .unwrap_or_default()
1696 .end(serializer, force_canonical)?;
1697 self.encodings
1698 .as_ref()
1699 .map(|encs| encs.len_encoding)
1700 .unwrap_or_default()
1701 .end(serializer, force_canonical)
1702 }
1703}
1704
1705impl Deserialize for ShelleyMoveInstantaneousReward {
1706 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1707 let len = raw.array_sz()?;
1708 let len_encoding: LenEncoding = len.into();
1709 let mut read_len = CBORReadLen::new(len);
1710 read_len.read_elems(2)?;
1711 read_len.finish()?;
1712 (|| -> Result<_, DeserializeError> {
1713 let (pot, pot_encoding) = (|| -> Result<_, DeserializeError> {
1714 let initial_position = raw.as_mut_ref().stream_position().unwrap();
1715 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1716 let (reserve_value, reserve_encoding) = raw.unsigned_integer_sz()?;
1717 if reserve_value != 0 {
1718 return Err(DeserializeFailure::FixedValueMismatch {
1719 found: Key::Uint(reserve_value),
1720 expected: Key::Uint(0),
1721 }
1722 .into());
1723 }
1724 Ok(Some(reserve_encoding))
1725 })(raw);
1726 match deser_variant {
1727 Ok(pot_encoding) => return Ok((MIRPot::Reserve, pot_encoding)),
1728 Err(_) => raw
1729 .as_mut_ref()
1730 .seek(SeekFrom::Start(initial_position))
1731 .unwrap(),
1732 };
1733 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1734 let (treasury_value, treasury_encoding) = raw.unsigned_integer_sz()?;
1735 if treasury_value != 1 {
1736 return Err(DeserializeFailure::FixedValueMismatch {
1737 found: Key::Uint(treasury_value),
1738 expected: Key::Uint(1),
1739 }
1740 .into());
1741 }
1742 Ok(Some(treasury_encoding))
1743 })(raw);
1744 match deser_variant {
1745 Ok(pot_encoding) => return Ok((MIRPot::Treasury, pot_encoding)),
1746 Err(_) => raw
1747 .as_mut_ref()
1748 .seek(SeekFrom::Start(initial_position))
1749 .unwrap(),
1750 };
1751 Err(DeserializeError::new(
1752 "MIRPot",
1753 DeserializeFailure::NoVariantMatched,
1754 ))
1755 })()
1756 .map_err(|e| e.annotate("pot"))?;
1757 let (
1758 to_stake_credentials,
1759 to_stake_credentials_encoding,
1760 to_stake_credentials_value_encodings,
1761 ) = (|| -> Result<_, DeserializeError> {
1762 let mut to_stake_credentials_table = OrderedHashMap::new();
1763 let to_stake_credentials_len = raw.map_sz()?;
1764 let to_stake_credentials_encoding = to_stake_credentials_len.into();
1765 let mut to_stake_credentials_value_encodings = BTreeMap::new();
1766 while match to_stake_credentials_len {
1767 cbor_event::LenSz::Len(n, _) => (to_stake_credentials_table.len() as u64) < n,
1768 cbor_event::LenSz::Indefinite => true,
1769 } {
1770 if raw.cbor_type()? == cbor_event::Type::Special {
1771 assert_eq!(raw.special()?, cbor_event::Special::Break);
1772 break;
1773 }
1774 let to_stake_credentials_key = StakeCredential::deserialize(raw)?;
1775 let (to_stake_credentials_value, to_stake_credentials_value_encoding) =
1776 raw.unsigned_integer_sz().map(|(x, enc)| (x, Some(enc)))?;
1777 if to_stake_credentials_table
1778 .insert(to_stake_credentials_key.clone(), to_stake_credentials_value)
1779 .is_some()
1780 {
1781 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1782 "some complicated/unsupported type",
1783 )))
1784 .into());
1785 }
1786 to_stake_credentials_value_encodings.insert(
1787 to_stake_credentials_key,
1788 to_stake_credentials_value_encoding,
1789 );
1790 }
1791 Ok((
1792 to_stake_credentials_table,
1793 to_stake_credentials_encoding,
1794 to_stake_credentials_value_encodings,
1795 ))
1796 })()
1797 .map_err(|e| e.annotate("to_stake_credentials"))?;
1798 match len {
1799 cbor_event::LenSz::Len(_, _) => (),
1800 cbor_event::LenSz::Indefinite => match raw.special()? {
1801 cbor_event::Special::Break => (),
1802 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1803 },
1804 }
1805 Ok(ShelleyMoveInstantaneousReward {
1806 pot,
1807 to_stake_credentials,
1808 encodings: Some(ShelleyMoveInstantaneousRewardEncoding {
1809 len_encoding,
1810 pot_encoding,
1811 to_stake_credentials_encoding,
1812 to_stake_credentials_value_encodings,
1813 }),
1814 })
1815 })()
1816 .map_err(|e| e.annotate("ShelleyMoveInstantaneousReward"))
1817 }
1818}
1819
1820impl Serialize for ShelleyMoveInstantaneousRewardsCert {
1821 fn serialize<'se, W: Write>(
1822 &self,
1823 serializer: &'se mut Serializer<W>,
1824 force_canonical: bool,
1825 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1826 serializer.write_array_sz(
1827 self.encodings
1828 .as_ref()
1829 .map(|encs| encs.len_encoding)
1830 .unwrap_or_default()
1831 .to_len_sz(2, force_canonical),
1832 )?;
1833 self.serialize_as_embedded_group(serializer, force_canonical)
1834 }
1835}
1836
1837impl SerializeEmbeddedGroup for ShelleyMoveInstantaneousRewardsCert {
1838 fn serialize_as_embedded_group<'se, W: Write>(
1839 &self,
1840 serializer: &'se mut Serializer<W>,
1841 force_canonical: bool,
1842 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1843 serializer.write_unsigned_integer_sz(
1844 6u64,
1845 fit_sz(
1846 6u64,
1847 self.encodings
1848 .as_ref()
1849 .map(|encs| encs.tag_encoding)
1850 .unwrap_or_default(),
1851 force_canonical,
1852 ),
1853 )?;
1854 self.shelley_move_instantaneous_reward
1855 .serialize(serializer, force_canonical)?;
1856 self.encodings
1857 .as_ref()
1858 .map(|encs| encs.len_encoding)
1859 .unwrap_or_default()
1860 .end(serializer, force_canonical)
1861 }
1862}
1863
1864impl Deserialize for ShelleyMoveInstantaneousRewardsCert {
1865 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1866 let len = raw.array_sz()?;
1867 let mut read_len = CBORReadLen::new(len);
1868 read_len.read_elems(2)?;
1869 read_len.finish()?;
1870 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1871 match len {
1872 cbor_event::LenSz::Len(_, _) => (),
1873 cbor_event::LenSz::Indefinite => match raw.special()? {
1874 cbor_event::Special::Break => (),
1875 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1876 },
1877 }
1878 ret
1879 }
1880}
1881
1882impl DeserializeEmbeddedGroup for ShelleyMoveInstantaneousRewardsCert {
1883 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1884 raw: &mut Deserializer<R>,
1885 _read_len: &mut CBORReadLen,
1886 len: cbor_event::LenSz,
1887 ) -> Result<Self, DeserializeError> {
1888 let len_encoding = len.into();
1889 (|| -> Result<_, DeserializeError> {
1890 let tag_encoding = (|| -> Result<_, DeserializeError> {
1891 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1892 if tag_value != 6 {
1893 return Err(DeserializeFailure::FixedValueMismatch {
1894 found: Key::Uint(tag_value),
1895 expected: Key::Uint(6),
1896 }
1897 .into());
1898 }
1899 Ok(Some(tag_encoding))
1900 })()
1901 .map_err(|e| e.annotate("tag"))?;
1902 let shelley_move_instantaneous_reward = ShelleyMoveInstantaneousReward::deserialize(
1903 raw,
1904 )
1905 .map_err(|e: DeserializeError| e.annotate("shelley_move_instantaneous_reward"))?;
1906 Ok(ShelleyMoveInstantaneousRewardsCert {
1907 shelley_move_instantaneous_reward,
1908 encodings: Some(ShelleyMoveInstantaneousRewardsCertEncoding {
1909 len_encoding,
1910 tag_encoding,
1911 }),
1912 })
1913 })()
1914 .map_err(|e| e.annotate("ShelleyMoveInstantaneousRewardsCert"))
1915 }
1916}
1917
1918impl Serialize for ShelleyMultiHostName {
1919 fn serialize<'se, W: Write>(
1920 &self,
1921 serializer: &'se mut Serializer<W>,
1922 force_canonical: bool,
1923 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1924 serializer.write_array_sz(
1925 self.encodings
1926 .as_ref()
1927 .map(|encs| encs.len_encoding)
1928 .unwrap_or_default()
1929 .to_len_sz(2, force_canonical),
1930 )?;
1931 self.serialize_as_embedded_group(serializer, force_canonical)
1932 }
1933}
1934
1935impl SerializeEmbeddedGroup for ShelleyMultiHostName {
1936 fn serialize_as_embedded_group<'se, W: Write>(
1937 &self,
1938 serializer: &'se mut Serializer<W>,
1939 force_canonical: bool,
1940 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1941 serializer.write_unsigned_integer_sz(
1942 2u64,
1943 fit_sz(
1944 2u64,
1945 self.encodings
1946 .as_ref()
1947 .map(|encs| encs.tag_encoding)
1948 .unwrap_or_default(),
1949 force_canonical,
1950 ),
1951 )?;
1952 self.shelley_dns_name
1953 .serialize(serializer, force_canonical)?;
1954 self.encodings
1955 .as_ref()
1956 .map(|encs| encs.len_encoding)
1957 .unwrap_or_default()
1958 .end(serializer, force_canonical)
1959 }
1960}
1961
1962impl Deserialize for ShelleyMultiHostName {
1963 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1964 let len = raw.array_sz()?;
1965 let mut read_len = CBORReadLen::new(len);
1966 read_len.read_elems(2)?;
1967 read_len.finish()?;
1968 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1969 match len {
1970 cbor_event::LenSz::Len(_, _) => (),
1971 cbor_event::LenSz::Indefinite => match raw.special()? {
1972 cbor_event::Special::Break => (),
1973 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1974 },
1975 }
1976 ret
1977 }
1978}
1979
1980impl DeserializeEmbeddedGroup for ShelleyMultiHostName {
1981 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1982 raw: &mut Deserializer<R>,
1983 _read_len: &mut CBORReadLen,
1984 len: cbor_event::LenSz,
1985 ) -> Result<Self, DeserializeError> {
1986 let len_encoding = len.into();
1987 (|| -> Result<_, DeserializeError> {
1988 let tag_encoding = (|| -> Result<_, DeserializeError> {
1989 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1990 if tag_value != 2 {
1991 return Err(DeserializeFailure::FixedValueMismatch {
1992 found: Key::Uint(tag_value),
1993 expected: Key::Uint(2),
1994 }
1995 .into());
1996 }
1997 Ok(Some(tag_encoding))
1998 })()
1999 .map_err(|e| e.annotate("tag"))?;
2000 let shelley_dns_name = ShelleyDNSName::deserialize(raw)
2001 .map_err(|e: DeserializeError| e.annotate("shelley_dns_name"))?;
2002 Ok(ShelleyMultiHostName {
2003 shelley_dns_name,
2004 encodings: Some(ShelleyMultiHostNameEncoding {
2005 len_encoding,
2006 tag_encoding,
2007 }),
2008 })
2009 })()
2010 .map_err(|e| e.annotate("ShelleyMultiHostName"))
2011 }
2012}
2013
2014impl Serialize for ShelleyPoolParams {
2015 fn serialize<'se, W: Write>(
2016 &self,
2017 serializer: &'se mut Serializer<W>,
2018 force_canonical: bool,
2019 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2020 serializer.write_array_sz(
2021 self.encodings
2022 .as_ref()
2023 .map(|encs| encs.len_encoding)
2024 .unwrap_or_default()
2025 .to_len_sz(9, force_canonical),
2026 )?;
2027 self.serialize_as_embedded_group(serializer, force_canonical)
2028 }
2029}
2030
2031impl SerializeEmbeddedGroup for ShelleyPoolParams {
2032 fn serialize_as_embedded_group<'se, W: Write>(
2033 &self,
2034 serializer: &'se mut Serializer<W>,
2035 force_canonical: bool,
2036 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2037 serializer.write_bytes_sz(
2038 self.operator.to_raw_bytes(),
2039 self.encodings
2040 .as_ref()
2041 .map(|encs| encs.operator_encoding.clone())
2042 .unwrap_or_default()
2043 .to_str_len_sz(self.operator.to_raw_bytes().len() as u64, force_canonical),
2044 )?;
2045 serializer.write_bytes_sz(
2046 self.vrf_keyhash.to_raw_bytes(),
2047 self.encodings
2048 .as_ref()
2049 .map(|encs| encs.vrf_keyhash_encoding.clone())
2050 .unwrap_or_default()
2051 .to_str_len_sz(
2052 self.vrf_keyhash.to_raw_bytes().len() as u64,
2053 force_canonical,
2054 ),
2055 )?;
2056 serializer.write_unsigned_integer_sz(
2057 self.pledge,
2058 fit_sz(
2059 self.pledge,
2060 self.encodings
2061 .as_ref()
2062 .map(|encs| encs.pledge_encoding)
2063 .unwrap_or_default(),
2064 force_canonical,
2065 ),
2066 )?;
2067 serializer.write_unsigned_integer_sz(
2068 self.cost,
2069 fit_sz(
2070 self.cost,
2071 self.encodings
2072 .as_ref()
2073 .map(|encs| encs.cost_encoding)
2074 .unwrap_or_default(),
2075 force_canonical,
2076 ),
2077 )?;
2078 self.margin.serialize(serializer, force_canonical)?;
2079 self.reward_account.serialize(serializer, force_canonical)?;
2080 serializer.write_array_sz(
2081 self.encodings
2082 .as_ref()
2083 .map(|encs| encs.pool_owners_encoding)
2084 .unwrap_or_default()
2085 .to_len_sz(self.pool_owners.len() as u64, force_canonical),
2086 )?;
2087 for (i, element) in self.pool_owners.iter().enumerate() {
2088 let pool_owners_elem_encoding = self
2089 .encodings
2090 .as_ref()
2091 .and_then(|encs| encs.pool_owners_elem_encodings.get(i))
2092 .cloned()
2093 .unwrap_or_default();
2094 serializer.write_bytes_sz(
2095 element.to_raw_bytes(),
2096 pool_owners_elem_encoding
2097 .to_str_len_sz(element.to_raw_bytes().len() as u64, force_canonical),
2098 )?;
2099 }
2100 self.encodings
2101 .as_ref()
2102 .map(|encs| encs.pool_owners_encoding)
2103 .unwrap_or_default()
2104 .end(serializer, force_canonical)?;
2105 serializer.write_array_sz(
2106 self.encodings
2107 .as_ref()
2108 .map(|encs| encs.relays_encoding)
2109 .unwrap_or_default()
2110 .to_len_sz(self.relays.len() as u64, force_canonical),
2111 )?;
2112 for element in self.relays.iter() {
2113 element.serialize(serializer, force_canonical)?;
2114 }
2115 self.encodings
2116 .as_ref()
2117 .map(|encs| encs.relays_encoding)
2118 .unwrap_or_default()
2119 .end(serializer, force_canonical)?;
2120 match &self.pool_metadata {
2121 Some(x) => x.serialize(serializer, force_canonical),
2122 None => serializer.write_special(cbor_event::Special::Null),
2123 }?;
2124 self.encodings
2125 .as_ref()
2126 .map(|encs| encs.len_encoding)
2127 .unwrap_or_default()
2128 .end(serializer, force_canonical)
2129 }
2130}
2131
2132impl Deserialize for ShelleyPoolParams {
2133 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2134 let len = raw.array_sz()?;
2135 let mut read_len = CBORReadLen::new(len);
2136 read_len.read_elems(9)?;
2137 read_len.finish()?;
2138 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2139 match len {
2140 cbor_event::LenSz::Len(_, _) => (),
2141 cbor_event::LenSz::Indefinite => match raw.special()? {
2142 cbor_event::Special::Break => (),
2143 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2144 },
2145 }
2146 ret
2147 }
2148}
2149
2150impl DeserializeEmbeddedGroup for ShelleyPoolParams {
2151 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2152 raw: &mut Deserializer<R>,
2153 _read_len: &mut CBORReadLen,
2154 len: cbor_event::LenSz,
2155 ) -> Result<Self, DeserializeError> {
2156 let len_encoding = len.into();
2157 (|| -> Result<_, DeserializeError> {
2158 let (operator, operator_encoding) = raw
2159 .bytes_sz()
2160 .map_err(Into::<DeserializeError>::into)
2161 .and_then(|(bytes, enc)| {
2162 Ed25519KeyHash::from_raw_bytes(&bytes)
2163 .map(|bytes| (bytes, StringEncoding::from(enc)))
2164 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
2165 })
2166 .map_err(|e: DeserializeError| e.annotate("operator"))?;
2167 let (vrf_keyhash, vrf_keyhash_encoding) = raw
2168 .bytes_sz()
2169 .map_err(Into::<DeserializeError>::into)
2170 .and_then(|(bytes, enc)| {
2171 VRFKeyHash::from_raw_bytes(&bytes)
2172 .map(|bytes| (bytes, StringEncoding::from(enc)))
2173 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
2174 })
2175 .map_err(|e: DeserializeError| e.annotate("vrf_keyhash"))?;
2176 let (pledge, pledge_encoding) = raw
2177 .unsigned_integer_sz()
2178 .map_err(Into::<DeserializeError>::into)
2179 .map(|(x, enc)| (x, Some(enc)))
2180 .map_err(|e: DeserializeError| e.annotate("pledge"))?;
2181 let (cost, cost_encoding) = raw
2182 .unsigned_integer_sz()
2183 .map_err(Into::<DeserializeError>::into)
2184 .map(|(x, enc)| (x, Some(enc)))
2185 .map_err(|e: DeserializeError| e.annotate("cost"))?;
2186 let margin = UnitInterval::deserialize(raw)
2187 .map_err(|e: DeserializeError| e.annotate("margin"))?;
2188 let reward_account = RewardAccount::deserialize(raw)
2189 .map_err(|e: DeserializeError| e.annotate("reward_account"))?;
2190 let (pool_owners, pool_owners_encoding, pool_owners_elem_encodings) =
2191 (|| -> Result<_, DeserializeError> {
2192 let mut pool_owners_arr = Vec::new();
2193 let len = raw.array_sz()?;
2194 let pool_owners_encoding = len.into();
2195 let mut pool_owners_elem_encodings = Vec::new();
2196 while match len {
2197 cbor_event::LenSz::Len(n, _) => (pool_owners_arr.len() as u64) < n,
2198 cbor_event::LenSz::Indefinite => true,
2199 } {
2200 if raw.cbor_type()? == cbor_event::Type::Special {
2201 assert_eq!(raw.special()?, cbor_event::Special::Break);
2202 break;
2203 }
2204 let (pool_owners_elem, pool_owners_elem_encoding) = raw
2205 .bytes_sz()
2206 .map_err(Into::<DeserializeError>::into)
2207 .and_then(|(bytes, enc)| {
2208 Ed25519KeyHash::from_raw_bytes(&bytes)
2209 .map(|bytes| (bytes, StringEncoding::from(enc)))
2210 .map_err(|e| {
2211 DeserializeFailure::InvalidStructure(Box::new(e)).into()
2212 })
2213 })?;
2214 pool_owners_arr.push(pool_owners_elem);
2215 pool_owners_elem_encodings.push(pool_owners_elem_encoding);
2216 }
2217 Ok((
2218 pool_owners_arr,
2219 pool_owners_encoding,
2220 pool_owners_elem_encodings,
2221 ))
2222 })()
2223 .map_err(|e| e.annotate("pool_owners"))?;
2224 let (relays, relays_encoding) = (|| -> Result<_, DeserializeError> {
2225 let mut relays_arr = Vec::new();
2226 let len = raw.array_sz()?;
2227 let relays_encoding = len.into();
2228 while match len {
2229 cbor_event::LenSz::Len(n, _) => (relays_arr.len() as u64) < n,
2230 cbor_event::LenSz::Indefinite => true,
2231 } {
2232 if raw.cbor_type()? == cbor_event::Type::Special {
2233 assert_eq!(raw.special()?, cbor_event::Special::Break);
2234 break;
2235 }
2236 relays_arr.push(ShelleyRelay::deserialize(raw)?);
2237 }
2238 Ok((relays_arr, relays_encoding))
2239 })()
2240 .map_err(|e| e.annotate("relays"))?;
2241 let pool_metadata = (|| -> Result<_, DeserializeError> {
2242 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
2243 true => Some(PoolMetadata::deserialize(raw)?),
2244 false => {
2245 if raw.special()? != cbor_event::Special::Null {
2246 return Err(DeserializeFailure::ExpectedNull.into());
2247 }
2248 None
2249 }
2250 })
2251 })()
2252 .map_err(|e| e.annotate("pool_metadata"))?;
2253 Ok(ShelleyPoolParams {
2254 operator,
2255 vrf_keyhash,
2256 pledge,
2257 cost,
2258 margin,
2259 reward_account,
2260 pool_owners,
2261 relays,
2262 pool_metadata,
2263 encodings: Some(ShelleyPoolParamsEncoding {
2264 len_encoding,
2265 operator_encoding,
2266 vrf_keyhash_encoding,
2267 pledge_encoding,
2268 cost_encoding,
2269 pool_owners_encoding,
2270 pool_owners_elem_encodings,
2271 relays_encoding,
2272 }),
2273 })
2274 })()
2275 .map_err(|e| e.annotate("ShelleyPoolParams"))
2276 }
2277}
2278
2279impl Serialize for ShelleyPoolRegistration {
2280 fn serialize<'se, W: Write>(
2281 &self,
2282 serializer: &'se mut Serializer<W>,
2283 force_canonical: bool,
2284 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2285 serializer.write_array_sz(
2286 self.encodings
2287 .as_ref()
2288 .map(|encs| encs.len_encoding)
2289 .unwrap_or_default()
2290 .to_len_sz(10, force_canonical),
2291 )?;
2292 self.serialize_as_embedded_group(serializer, force_canonical)
2293 }
2294}
2295
2296impl SerializeEmbeddedGroup for ShelleyPoolRegistration {
2297 fn serialize_as_embedded_group<'se, W: Write>(
2298 &self,
2299 serializer: &'se mut Serializer<W>,
2300 force_canonical: bool,
2301 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2302 serializer.write_unsigned_integer_sz(
2303 3u64,
2304 fit_sz(
2305 3u64,
2306 self.encodings
2307 .as_ref()
2308 .map(|encs| encs.tag_encoding)
2309 .unwrap_or_default(),
2310 force_canonical,
2311 ),
2312 )?;
2313 self.pool_params
2314 .serialize_as_embedded_group(serializer, force_canonical)?;
2315 self.encodings
2316 .as_ref()
2317 .map(|encs| encs.len_encoding)
2318 .unwrap_or_default()
2319 .end(serializer, force_canonical)
2320 }
2321}
2322
2323impl Deserialize for ShelleyPoolRegistration {
2324 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2325 let len = raw.array_sz()?;
2326 let mut read_len = CBORReadLen::new(len);
2327 read_len.read_elems(10)?;
2328 read_len.finish()?;
2329 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2330 match len {
2331 cbor_event::LenSz::Len(_, _) => (),
2332 cbor_event::LenSz::Indefinite => match raw.special()? {
2333 cbor_event::Special::Break => (),
2334 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2335 },
2336 }
2337 ret
2338 }
2339}
2340
2341impl DeserializeEmbeddedGroup for ShelleyPoolRegistration {
2342 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2343 raw: &mut Deserializer<R>,
2344 read_len: &mut CBORReadLen,
2345 len: cbor_event::LenSz,
2346 ) -> Result<Self, DeserializeError> {
2347 let len_encoding = len.into();
2348 (|| -> Result<_, DeserializeError> {
2349 let tag_encoding = (|| -> Result<_, DeserializeError> {
2350 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2351 if tag_value != 3 {
2352 return Err(DeserializeFailure::FixedValueMismatch {
2353 found: Key::Uint(tag_value),
2354 expected: Key::Uint(3),
2355 }
2356 .into());
2357 }
2358 Ok(Some(tag_encoding))
2359 })()
2360 .map_err(|e| e.annotate("tag"))?;
2361 let pool_params = ShelleyPoolParams::deserialize_as_embedded_group(raw, read_len, len)
2362 .map_err(|e: DeserializeError| e.annotate("pool_params"))?;
2363 Ok(ShelleyPoolRegistration {
2364 pool_params,
2365 encodings: Some(ShelleyPoolRegistrationEncoding {
2366 len_encoding,
2367 tag_encoding,
2368 }),
2369 })
2370 })()
2371 .map_err(|e| e.annotate("ShelleyPoolRegistration"))
2372 }
2373}
2374
2375impl Serialize for ShelleyProtocolParamUpdate {
2376 fn serialize<'se, W: Write>(
2377 &self,
2378 serializer: &'se mut Serializer<W>,
2379 force_canonical: bool,
2380 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2381 serializer.write_map_sz(
2382 self.encodings
2383 .as_ref()
2384 .map(|encs| encs.len_encoding)
2385 .unwrap_or_default()
2386 .to_len_sz(
2387 match &self.minfee_a {
2388 Some(_) => 1,
2389 None => 0,
2390 } + match &self.minfee_b {
2391 Some(_) => 1,
2392 None => 0,
2393 } + match &self.max_block_body_size {
2394 Some(_) => 1,
2395 None => 0,
2396 } + match &self.max_transaction_size {
2397 Some(_) => 1,
2398 None => 0,
2399 } + match &self.max_block_header_size {
2400 Some(_) => 1,
2401 None => 0,
2402 } + match &self.key_deposit {
2403 Some(_) => 1,
2404 None => 0,
2405 } + match &self.pool_deposit {
2406 Some(_) => 1,
2407 None => 0,
2408 } + match &self.maximum_epoch {
2409 Some(_) => 1,
2410 None => 0,
2411 } + match &self.n_opt {
2412 Some(_) => 1,
2413 None => 0,
2414 } + match &self.pool_pledge_influence {
2415 Some(_) => 1,
2416 None => 0,
2417 } + match &self.expansion_rate {
2418 Some(_) => 1,
2419 None => 0,
2420 } + match &self.treasury_growth_rate {
2421 Some(_) => 1,
2422 None => 0,
2423 } + match &self.decentralization_constant {
2424 Some(_) => 1,
2425 None => 0,
2426 } + match &self.extra_entropy {
2427 Some(_) => 1,
2428 None => 0,
2429 } + match &self.protocol_version {
2430 Some(_) => 1,
2431 None => 0,
2432 } + match &self.min_utxo_value {
2433 Some(_) => 1,
2434 None => 0,
2435 },
2436 force_canonical,
2437 ),
2438 )?;
2439 let deser_order = self
2440 .encodings
2441 .as_ref()
2442 .filter(|encs| {
2443 !force_canonical
2444 && encs.orig_deser_order.len()
2445 == match &self.minfee_a {
2446 Some(_) => 1,
2447 None => 0,
2448 } + match &self.minfee_b {
2449 Some(_) => 1,
2450 None => 0,
2451 } + match &self.max_block_body_size {
2452 Some(_) => 1,
2453 None => 0,
2454 } + match &self.max_transaction_size {
2455 Some(_) => 1,
2456 None => 0,
2457 } + match &self.max_block_header_size {
2458 Some(_) => 1,
2459 None => 0,
2460 } + match &self.key_deposit {
2461 Some(_) => 1,
2462 None => 0,
2463 } + match &self.pool_deposit {
2464 Some(_) => 1,
2465 None => 0,
2466 } + match &self.maximum_epoch {
2467 Some(_) => 1,
2468 None => 0,
2469 } + match &self.n_opt {
2470 Some(_) => 1,
2471 None => 0,
2472 } + match &self.pool_pledge_influence {
2473 Some(_) => 1,
2474 None => 0,
2475 } + match &self.expansion_rate {
2476 Some(_) => 1,
2477 None => 0,
2478 } + match &self.treasury_growth_rate {
2479 Some(_) => 1,
2480 None => 0,
2481 } + match &self.decentralization_constant {
2482 Some(_) => 1,
2483 None => 0,
2484 } + match &self.extra_entropy {
2485 Some(_) => 1,
2486 None => 0,
2487 } + match &self.protocol_version {
2488 Some(_) => 1,
2489 None => 0,
2490 } + match &self.min_utxo_value {
2491 Some(_) => 1,
2492 None => 0,
2493 }
2494 })
2495 .map(|encs| encs.orig_deser_order.clone())
2496 .unwrap_or_else(|| vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
2497 for field_index in deser_order {
2498 match field_index {
2499 0 => {
2500 if let Some(field) = &self.minfee_a {
2501 serializer.write_unsigned_integer_sz(
2502 0u64,
2503 fit_sz(
2504 0u64,
2505 self.encodings
2506 .as_ref()
2507 .map(|encs| encs.minfee_a_key_encoding)
2508 .unwrap_or_default(),
2509 force_canonical,
2510 ),
2511 )?;
2512 serializer.write_unsigned_integer_sz(
2513 *field,
2514 fit_sz(
2515 *field,
2516 self.encodings
2517 .as_ref()
2518 .map(|encs| encs.minfee_a_encoding)
2519 .unwrap_or_default(),
2520 force_canonical,
2521 ),
2522 )?;
2523 }
2524 }
2525 1 => {
2526 if let Some(field) = &self.minfee_b {
2527 serializer.write_unsigned_integer_sz(
2528 1u64,
2529 fit_sz(
2530 1u64,
2531 self.encodings
2532 .as_ref()
2533 .map(|encs| encs.minfee_b_key_encoding)
2534 .unwrap_or_default(),
2535 force_canonical,
2536 ),
2537 )?;
2538 serializer.write_unsigned_integer_sz(
2539 *field,
2540 fit_sz(
2541 *field,
2542 self.encodings
2543 .as_ref()
2544 .map(|encs| encs.minfee_b_encoding)
2545 .unwrap_or_default(),
2546 force_canonical,
2547 ),
2548 )?;
2549 }
2550 }
2551 2 => {
2552 if let Some(field) = &self.max_block_body_size {
2553 serializer.write_unsigned_integer_sz(
2554 2u64,
2555 fit_sz(
2556 2u64,
2557 self.encodings
2558 .as_ref()
2559 .map(|encs| encs.max_block_body_size_key_encoding)
2560 .unwrap_or_default(),
2561 force_canonical,
2562 ),
2563 )?;
2564 serializer.write_unsigned_integer_sz(
2565 *field,
2566 fit_sz(
2567 *field,
2568 self.encodings
2569 .as_ref()
2570 .map(|encs| encs.max_block_body_size_encoding)
2571 .unwrap_or_default(),
2572 force_canonical,
2573 ),
2574 )?;
2575 }
2576 }
2577 3 => {
2578 if let Some(field) = &self.max_transaction_size {
2579 serializer.write_unsigned_integer_sz(
2580 3u64,
2581 fit_sz(
2582 3u64,
2583 self.encodings
2584 .as_ref()
2585 .map(|encs| encs.max_transaction_size_key_encoding)
2586 .unwrap_or_default(),
2587 force_canonical,
2588 ),
2589 )?;
2590 serializer.write_unsigned_integer_sz(
2591 *field,
2592 fit_sz(
2593 *field,
2594 self.encodings
2595 .as_ref()
2596 .map(|encs| encs.max_transaction_size_encoding)
2597 .unwrap_or_default(),
2598 force_canonical,
2599 ),
2600 )?;
2601 }
2602 }
2603 4 => {
2604 if let Some(field) = &self.max_block_header_size {
2605 serializer.write_unsigned_integer_sz(
2606 4u64,
2607 fit_sz(
2608 4u64,
2609 self.encodings
2610 .as_ref()
2611 .map(|encs| encs.max_block_header_size_key_encoding)
2612 .unwrap_or_default(),
2613 force_canonical,
2614 ),
2615 )?;
2616 serializer.write_unsigned_integer_sz(
2617 *field,
2618 fit_sz(
2619 *field,
2620 self.encodings
2621 .as_ref()
2622 .map(|encs| encs.max_block_header_size_encoding)
2623 .unwrap_or_default(),
2624 force_canonical,
2625 ),
2626 )?;
2627 }
2628 }
2629 5 => {
2630 if let Some(field) = &self.key_deposit {
2631 serializer.write_unsigned_integer_sz(
2632 5u64,
2633 fit_sz(
2634 5u64,
2635 self.encodings
2636 .as_ref()
2637 .map(|encs| encs.key_deposit_key_encoding)
2638 .unwrap_or_default(),
2639 force_canonical,
2640 ),
2641 )?;
2642 serializer.write_unsigned_integer_sz(
2643 *field,
2644 fit_sz(
2645 *field,
2646 self.encodings
2647 .as_ref()
2648 .map(|encs| encs.key_deposit_encoding)
2649 .unwrap_or_default(),
2650 force_canonical,
2651 ),
2652 )?;
2653 }
2654 }
2655 6 => {
2656 if let Some(field) = &self.pool_deposit {
2657 serializer.write_unsigned_integer_sz(
2658 6u64,
2659 fit_sz(
2660 6u64,
2661 self.encodings
2662 .as_ref()
2663 .map(|encs| encs.pool_deposit_key_encoding)
2664 .unwrap_or_default(),
2665 force_canonical,
2666 ),
2667 )?;
2668 serializer.write_unsigned_integer_sz(
2669 *field,
2670 fit_sz(
2671 *field,
2672 self.encodings
2673 .as_ref()
2674 .map(|encs| encs.pool_deposit_encoding)
2675 .unwrap_or_default(),
2676 force_canonical,
2677 ),
2678 )?;
2679 }
2680 }
2681 7 => {
2682 if let Some(field) = &self.maximum_epoch {
2683 serializer.write_unsigned_integer_sz(
2684 7u64,
2685 fit_sz(
2686 7u64,
2687 self.encodings
2688 .as_ref()
2689 .map(|encs| encs.maximum_epoch_key_encoding)
2690 .unwrap_or_default(),
2691 force_canonical,
2692 ),
2693 )?;
2694 serializer.write_unsigned_integer_sz(
2695 *field,
2696 fit_sz(
2697 *field,
2698 self.encodings
2699 .as_ref()
2700 .map(|encs| encs.maximum_epoch_encoding)
2701 .unwrap_or_default(),
2702 force_canonical,
2703 ),
2704 )?;
2705 }
2706 }
2707 8 => {
2708 if let Some(field) = &self.n_opt {
2709 serializer.write_unsigned_integer_sz(
2710 8u64,
2711 fit_sz(
2712 8u64,
2713 self.encodings
2714 .as_ref()
2715 .map(|encs| encs.n_opt_key_encoding)
2716 .unwrap_or_default(),
2717 force_canonical,
2718 ),
2719 )?;
2720 serializer.write_unsigned_integer_sz(
2721 *field,
2722 fit_sz(
2723 *field,
2724 self.encodings
2725 .as_ref()
2726 .map(|encs| encs.n_opt_encoding)
2727 .unwrap_or_default(),
2728 force_canonical,
2729 ),
2730 )?;
2731 }
2732 }
2733 9 => {
2734 if let Some(field) = &self.pool_pledge_influence {
2735 serializer.write_unsigned_integer_sz(
2736 9u64,
2737 fit_sz(
2738 9u64,
2739 self.encodings
2740 .as_ref()
2741 .map(|encs| encs.pool_pledge_influence_key_encoding)
2742 .unwrap_or_default(),
2743 force_canonical,
2744 ),
2745 )?;
2746 field.serialize(serializer, force_canonical)?;
2747 }
2748 }
2749 10 => {
2750 if let Some(field) = &self.expansion_rate {
2751 serializer.write_unsigned_integer_sz(
2752 10u64,
2753 fit_sz(
2754 10u64,
2755 self.encodings
2756 .as_ref()
2757 .map(|encs| encs.expansion_rate_key_encoding)
2758 .unwrap_or_default(),
2759 force_canonical,
2760 ),
2761 )?;
2762 field.serialize(serializer, force_canonical)?;
2763 }
2764 }
2765 11 => {
2766 if let Some(field) = &self.treasury_growth_rate {
2767 serializer.write_unsigned_integer_sz(
2768 11u64,
2769 fit_sz(
2770 11u64,
2771 self.encodings
2772 .as_ref()
2773 .map(|encs| encs.treasury_growth_rate_key_encoding)
2774 .unwrap_or_default(),
2775 force_canonical,
2776 ),
2777 )?;
2778 field.serialize(serializer, force_canonical)?;
2779 }
2780 }
2781 12 => {
2782 if let Some(field) = &self.decentralization_constant {
2783 serializer.write_unsigned_integer_sz(
2784 12u64,
2785 fit_sz(
2786 12u64,
2787 self.encodings
2788 .as_ref()
2789 .map(|encs| encs.decentralization_constant_key_encoding)
2790 .unwrap_or_default(),
2791 force_canonical,
2792 ),
2793 )?;
2794 field.serialize(serializer, force_canonical)?;
2795 }
2796 }
2797 13 => {
2798 if let Some(field) = &self.extra_entropy {
2799 serializer.write_unsigned_integer_sz(
2800 13u64,
2801 fit_sz(
2802 13u64,
2803 self.encodings
2804 .as_ref()
2805 .map(|encs| encs.extra_entropy_key_encoding)
2806 .unwrap_or_default(),
2807 force_canonical,
2808 ),
2809 )?;
2810 field.serialize(serializer, force_canonical)?;
2811 }
2812 }
2813 14 => {
2814 if let Some(field) = &self.protocol_version {
2815 serializer.write_unsigned_integer_sz(
2816 14u64,
2817 fit_sz(
2818 14u64,
2819 self.encodings
2820 .as_ref()
2821 .map(|encs| encs.protocol_version_key_encoding)
2822 .unwrap_or_default(),
2823 force_canonical,
2824 ),
2825 )?;
2826 field.serialize(serializer, force_canonical)?;
2827 }
2828 }
2829 15 => {
2830 if let Some(field) = &self.min_utxo_value {
2831 serializer.write_unsigned_integer_sz(
2832 15u64,
2833 fit_sz(
2834 15u64,
2835 self.encodings
2836 .as_ref()
2837 .map(|encs| encs.min_utxo_value_key_encoding)
2838 .unwrap_or_default(),
2839 force_canonical,
2840 ),
2841 )?;
2842 serializer.write_unsigned_integer_sz(
2843 *field,
2844 fit_sz(
2845 *field,
2846 self.encodings
2847 .as_ref()
2848 .map(|encs| encs.min_utxo_value_encoding)
2849 .unwrap_or_default(),
2850 force_canonical,
2851 ),
2852 )?;
2853 }
2854 }
2855 _ => unreachable!(),
2856 };
2857 }
2858 self.encodings
2859 .as_ref()
2860 .map(|encs| encs.len_encoding)
2861 .unwrap_or_default()
2862 .end(serializer, force_canonical)
2863 }
2864}
2865
2866impl Deserialize for ShelleyProtocolParamUpdate {
2867 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2868 let len = raw.map_sz()?;
2869 let len_encoding: LenEncoding = len.into();
2870 let mut read_len = CBORReadLen::new(len);
2871 (|| -> Result<_, DeserializeError> {
2872 let mut orig_deser_order = Vec::new();
2873 let mut minfee_a_encoding = None;
2874 let mut minfee_a_key_encoding = None;
2875 let mut minfee_a = None;
2876 let mut minfee_b_encoding = None;
2877 let mut minfee_b_key_encoding = None;
2878 let mut minfee_b = None;
2879 let mut max_block_body_size_encoding = None;
2880 let mut max_block_body_size_key_encoding = None;
2881 let mut max_block_body_size = None;
2882 let mut max_transaction_size_encoding = None;
2883 let mut max_transaction_size_key_encoding = None;
2884 let mut max_transaction_size = None;
2885 let mut max_block_header_size_encoding = None;
2886 let mut max_block_header_size_key_encoding = None;
2887 let mut max_block_header_size = None;
2888 let mut key_deposit_encoding = None;
2889 let mut key_deposit_key_encoding = None;
2890 let mut key_deposit = None;
2891 let mut pool_deposit_encoding = None;
2892 let mut pool_deposit_key_encoding = None;
2893 let mut pool_deposit = None;
2894 let mut maximum_epoch_encoding = None;
2895 let mut maximum_epoch_key_encoding = None;
2896 let mut maximum_epoch = None;
2897 let mut n_opt_encoding = None;
2898 let mut n_opt_key_encoding = None;
2899 let mut n_opt = None;
2900 let mut pool_pledge_influence_key_encoding = None;
2901 let mut pool_pledge_influence = None;
2902 let mut expansion_rate_key_encoding = None;
2903 let mut expansion_rate = None;
2904 let mut treasury_growth_rate_key_encoding = None;
2905 let mut treasury_growth_rate = None;
2906 let mut decentralization_constant_key_encoding = None;
2907 let mut decentralization_constant = None;
2908 let mut extra_entropy_key_encoding = None;
2909 let mut extra_entropy = None;
2910 let mut protocol_version_key_encoding = None;
2911 let mut protocol_version = None;
2912 let mut min_utxo_value_encoding = None;
2913 let mut min_utxo_value_key_encoding = None;
2914 let mut min_utxo_value = None;
2915 let mut read = 0;
2916 while match len {
2917 cbor_event::LenSz::Len(n, _) => read < n,
2918 cbor_event::LenSz::Indefinite => true,
2919 } {
2920 match raw.cbor_type()? {
2921 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
2922 (0, key_enc) => {
2923 if minfee_a.is_some() {
2924 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
2925 }
2926 let (tmp_minfee_a, tmp_minfee_a_encoding) =
2927 (|| -> Result<_, DeserializeError> {
2928 read_len.read_elems(1)?;
2929 raw.unsigned_integer_sz()
2930 .map_err(Into::<DeserializeError>::into)
2931 .map(|(x, enc)| (x, Some(enc)))
2932 })()
2933 .map_err(|e| e.annotate("minfee_a"))?;
2934 minfee_a = Some(tmp_minfee_a);
2935 minfee_a_encoding = tmp_minfee_a_encoding;
2936 minfee_a_key_encoding = Some(key_enc);
2937 orig_deser_order.push(0);
2938 }
2939 (1, key_enc) => {
2940 if minfee_b.is_some() {
2941 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
2942 }
2943 let (tmp_minfee_b, tmp_minfee_b_encoding) =
2944 (|| -> Result<_, DeserializeError> {
2945 read_len.read_elems(1)?;
2946 raw.unsigned_integer_sz()
2947 .map_err(Into::<DeserializeError>::into)
2948 .map(|(x, enc)| (x, Some(enc)))
2949 })()
2950 .map_err(|e| e.annotate("minfee_b"))?;
2951 minfee_b = Some(tmp_minfee_b);
2952 minfee_b_encoding = tmp_minfee_b_encoding;
2953 minfee_b_key_encoding = Some(key_enc);
2954 orig_deser_order.push(1);
2955 }
2956 (2, key_enc) => {
2957 if max_block_body_size.is_some() {
2958 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
2959 }
2960 let (tmp_max_block_body_size, tmp_max_block_body_size_encoding) =
2961 (|| -> Result<_, DeserializeError> {
2962 read_len.read_elems(1)?;
2963 raw.unsigned_integer_sz()
2964 .map_err(Into::<DeserializeError>::into)
2965 .map(|(x, enc)| (x, Some(enc)))
2966 })()
2967 .map_err(|e| e.annotate("max_block_body_size"))?;
2968 max_block_body_size = Some(tmp_max_block_body_size);
2969 max_block_body_size_encoding = tmp_max_block_body_size_encoding;
2970 max_block_body_size_key_encoding = Some(key_enc);
2971 orig_deser_order.push(2);
2972 }
2973 (3, key_enc) => {
2974 if max_transaction_size.is_some() {
2975 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
2976 }
2977 let (tmp_max_transaction_size, tmp_max_transaction_size_encoding) =
2978 (|| -> Result<_, DeserializeError> {
2979 read_len.read_elems(1)?;
2980 raw.unsigned_integer_sz()
2981 .map_err(Into::<DeserializeError>::into)
2982 .map(|(x, enc)| (x, Some(enc)))
2983 })()
2984 .map_err(|e| e.annotate("max_transaction_size"))?;
2985 max_transaction_size = Some(tmp_max_transaction_size);
2986 max_transaction_size_encoding = tmp_max_transaction_size_encoding;
2987 max_transaction_size_key_encoding = Some(key_enc);
2988 orig_deser_order.push(3);
2989 }
2990 (4, key_enc) => {
2991 if max_block_header_size.is_some() {
2992 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
2993 }
2994 let (tmp_max_block_header_size, tmp_max_block_header_size_encoding) =
2995 (|| -> Result<_, DeserializeError> {
2996 read_len.read_elems(1)?;
2997 raw.unsigned_integer_sz()
2998 .map_err(Into::<DeserializeError>::into)
2999 .map(|(x, enc)| (x, Some(enc)))
3000 })()
3001 .map_err(|e| e.annotate("max_block_header_size"))?;
3002 max_block_header_size = Some(tmp_max_block_header_size);
3003 max_block_header_size_encoding = tmp_max_block_header_size_encoding;
3004 max_block_header_size_key_encoding = Some(key_enc);
3005 orig_deser_order.push(4);
3006 }
3007 (5, key_enc) => {
3008 if key_deposit.is_some() {
3009 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
3010 }
3011 let (tmp_key_deposit, tmp_key_deposit_encoding) =
3012 (|| -> Result<_, DeserializeError> {
3013 read_len.read_elems(1)?;
3014 raw.unsigned_integer_sz()
3015 .map_err(Into::<DeserializeError>::into)
3016 .map(|(x, enc)| (x, Some(enc)))
3017 })()
3018 .map_err(|e| e.annotate("key_deposit"))?;
3019 key_deposit = Some(tmp_key_deposit);
3020 key_deposit_encoding = tmp_key_deposit_encoding;
3021 key_deposit_key_encoding = Some(key_enc);
3022 orig_deser_order.push(5);
3023 }
3024 (6, key_enc) => {
3025 if pool_deposit.is_some() {
3026 return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
3027 }
3028 let (tmp_pool_deposit, tmp_pool_deposit_encoding) =
3029 (|| -> Result<_, DeserializeError> {
3030 read_len.read_elems(1)?;
3031 raw.unsigned_integer_sz()
3032 .map_err(Into::<DeserializeError>::into)
3033 .map(|(x, enc)| (x, Some(enc)))
3034 })()
3035 .map_err(|e| e.annotate("pool_deposit"))?;
3036 pool_deposit = Some(tmp_pool_deposit);
3037 pool_deposit_encoding = tmp_pool_deposit_encoding;
3038 pool_deposit_key_encoding = Some(key_enc);
3039 orig_deser_order.push(6);
3040 }
3041 (7, key_enc) => {
3042 if maximum_epoch.is_some() {
3043 return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
3044 }
3045 let (tmp_maximum_epoch, tmp_maximum_epoch_encoding) =
3046 (|| -> Result<_, DeserializeError> {
3047 read_len.read_elems(1)?;
3048 raw.unsigned_integer_sz()
3049 .map_err(Into::<DeserializeError>::into)
3050 .map(|(x, enc)| (x, Some(enc)))
3051 })()
3052 .map_err(|e| e.annotate("maximum_epoch"))?;
3053 maximum_epoch = Some(tmp_maximum_epoch);
3054 maximum_epoch_encoding = tmp_maximum_epoch_encoding;
3055 maximum_epoch_key_encoding = Some(key_enc);
3056 orig_deser_order.push(7);
3057 }
3058 (8, key_enc) => {
3059 if n_opt.is_some() {
3060 return Err(DeserializeFailure::DuplicateKey(Key::Uint(8)).into());
3061 }
3062 let (tmp_n_opt, tmp_n_opt_encoding) =
3063 (|| -> Result<_, DeserializeError> {
3064 read_len.read_elems(1)?;
3065 raw.unsigned_integer_sz()
3066 .map_err(Into::<DeserializeError>::into)
3067 .map(|(x, enc)| (x, Some(enc)))
3068 })()
3069 .map_err(|e| e.annotate("n_opt"))?;
3070 n_opt = Some(tmp_n_opt);
3071 n_opt_encoding = tmp_n_opt_encoding;
3072 n_opt_key_encoding = Some(key_enc);
3073 orig_deser_order.push(8);
3074 }
3075 (9, key_enc) => {
3076 if pool_pledge_influence.is_some() {
3077 return Err(DeserializeFailure::DuplicateKey(Key::Uint(9)).into());
3078 }
3079 let tmp_pool_pledge_influence = (|| -> Result<_, DeserializeError> {
3080 read_len.read_elems(1)?;
3081 Rational::deserialize(raw)
3082 })()
3083 .map_err(|e| e.annotate("pool_pledge_influence"))?;
3084 pool_pledge_influence = Some(tmp_pool_pledge_influence);
3085 pool_pledge_influence_key_encoding = Some(key_enc);
3086 orig_deser_order.push(9);
3087 }
3088 (10, key_enc) => {
3089 if expansion_rate.is_some() {
3090 return Err(DeserializeFailure::DuplicateKey(Key::Uint(10)).into());
3091 }
3092 let tmp_expansion_rate = (|| -> Result<_, DeserializeError> {
3093 read_len.read_elems(1)?;
3094 UnitInterval::deserialize(raw)
3095 })()
3096 .map_err(|e| e.annotate("expansion_rate"))?;
3097 expansion_rate = Some(tmp_expansion_rate);
3098 expansion_rate_key_encoding = Some(key_enc);
3099 orig_deser_order.push(10);
3100 }
3101 (11, key_enc) => {
3102 if treasury_growth_rate.is_some() {
3103 return Err(DeserializeFailure::DuplicateKey(Key::Uint(11)).into());
3104 }
3105 let tmp_treasury_growth_rate = (|| -> Result<_, DeserializeError> {
3106 read_len.read_elems(1)?;
3107 UnitInterval::deserialize(raw)
3108 })()
3109 .map_err(|e| e.annotate("treasury_growth_rate"))?;
3110 treasury_growth_rate = Some(tmp_treasury_growth_rate);
3111 treasury_growth_rate_key_encoding = Some(key_enc);
3112 orig_deser_order.push(11);
3113 }
3114 (12, key_enc) => {
3115 if decentralization_constant.is_some() {
3116 return Err(DeserializeFailure::DuplicateKey(Key::Uint(12)).into());
3117 }
3118 let tmp_decentralization_constant =
3119 (|| -> Result<_, DeserializeError> {
3120 read_len.read_elems(1)?;
3121 UnitInterval::deserialize(raw)
3122 })()
3123 .map_err(|e| e.annotate("decentralization_constant"))?;
3124 decentralization_constant = Some(tmp_decentralization_constant);
3125 decentralization_constant_key_encoding = Some(key_enc);
3126 orig_deser_order.push(12);
3127 }
3128 (13, key_enc) => {
3129 if extra_entropy.is_some() {
3130 return Err(DeserializeFailure::DuplicateKey(Key::Uint(13)).into());
3131 }
3132 let tmp_extra_entropy = (|| -> Result<_, DeserializeError> {
3133 read_len.read_elems(1)?;
3134 Nonce::deserialize(raw)
3135 })()
3136 .map_err(|e| e.annotate("extra_entropy"))?;
3137 extra_entropy = Some(tmp_extra_entropy);
3138 extra_entropy_key_encoding = Some(key_enc);
3139 orig_deser_order.push(13);
3140 }
3141 (14, key_enc) => {
3142 if protocol_version.is_some() {
3143 return Err(DeserializeFailure::DuplicateKey(Key::Uint(14)).into());
3144 }
3145 let tmp_protocol_version = (|| -> Result<_, DeserializeError> {
3146 read_len.read_elems(1)?;
3147 ProtocolVersionStruct::deserialize(raw)
3148 })()
3149 .map_err(|e| e.annotate("protocol_version"))?;
3150 protocol_version = Some(tmp_protocol_version);
3151 protocol_version_key_encoding = Some(key_enc);
3152 orig_deser_order.push(14);
3153 }
3154 (15, key_enc) => {
3155 if min_utxo_value.is_some() {
3156 return Err(DeserializeFailure::DuplicateKey(Key::Uint(15)).into());
3157 }
3158 let (tmp_min_utxo_value, tmp_min_utxo_value_encoding) =
3159 (|| -> Result<_, DeserializeError> {
3160 read_len.read_elems(1)?;
3161 raw.unsigned_integer_sz()
3162 .map_err(Into::<DeserializeError>::into)
3163 .map(|(x, enc)| (x, Some(enc)))
3164 })()
3165 .map_err(|e| e.annotate("min_utxo_value"))?;
3166 min_utxo_value = Some(tmp_min_utxo_value);
3167 min_utxo_value_encoding = tmp_min_utxo_value_encoding;
3168 min_utxo_value_key_encoding = Some(key_enc);
3169 orig_deser_order.push(15);
3170 }
3171 (unknown_key, _enc) => {
3172 return Err(
3173 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
3174 )
3175 }
3176 },
3177 cbor_event::Type::Text => {
3178 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
3179 }
3180 cbor_event::Type::Special => match len {
3181 cbor_event::LenSz::Len(_, _) => {
3182 return Err(DeserializeFailure::BreakInDefiniteLen.into())
3183 }
3184 cbor_event::LenSz::Indefinite => match raw.special()? {
3185 cbor_event::Special::Break => break,
3186 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3187 },
3188 },
3189 other_type => {
3190 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
3191 }
3192 }
3193 read += 1;
3194 }
3195 read_len.finish()?;
3196 Ok(Self {
3197 minfee_a,
3198 minfee_b,
3199 max_block_body_size,
3200 max_transaction_size,
3201 max_block_header_size,
3202 key_deposit,
3203 pool_deposit,
3204 maximum_epoch,
3205 n_opt,
3206 pool_pledge_influence,
3207 expansion_rate,
3208 treasury_growth_rate,
3209 decentralization_constant,
3210 extra_entropy,
3211 protocol_version,
3212 min_utxo_value,
3213 encodings: Some(ShelleyProtocolParamUpdateEncoding {
3214 len_encoding,
3215 orig_deser_order,
3216 minfee_a_key_encoding,
3217 minfee_a_encoding,
3218 minfee_b_key_encoding,
3219 minfee_b_encoding,
3220 max_block_body_size_key_encoding,
3221 max_block_body_size_encoding,
3222 max_transaction_size_key_encoding,
3223 max_transaction_size_encoding,
3224 max_block_header_size_key_encoding,
3225 max_block_header_size_encoding,
3226 key_deposit_key_encoding,
3227 key_deposit_encoding,
3228 pool_deposit_key_encoding,
3229 pool_deposit_encoding,
3230 maximum_epoch_key_encoding,
3231 maximum_epoch_encoding,
3232 n_opt_key_encoding,
3233 n_opt_encoding,
3234 pool_pledge_influence_key_encoding,
3235 expansion_rate_key_encoding,
3236 treasury_growth_rate_key_encoding,
3237 decentralization_constant_key_encoding,
3238 extra_entropy_key_encoding,
3239 protocol_version_key_encoding,
3240 min_utxo_value_key_encoding,
3241 min_utxo_value_encoding,
3242 }),
3243 })
3244 })()
3245 .map_err(|e| e.annotate("ShelleyProtocolParamUpdate"))
3246 }
3247}
3248
3249impl Serialize for ShelleyRelay {
3250 fn serialize<'se, W: Write>(
3251 &self,
3252 serializer: &'se mut Serializer<W>,
3253 force_canonical: bool,
3254 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3255 match self {
3256 ShelleyRelay::SingleHostAddr(single_host_addr) => {
3257 single_host_addr.serialize(serializer, force_canonical)
3258 }
3259 ShelleyRelay::ShelleySingleHostName(shelley_single_host_name) => {
3260 shelley_single_host_name.serialize(serializer, force_canonical)
3261 }
3262 ShelleyRelay::ShelleyMultiHostName(shelley_multi_host_name) => {
3263 shelley_multi_host_name.serialize(serializer, force_canonical)
3264 }
3265 }
3266 }
3267}
3268
3269impl Deserialize for ShelleyRelay {
3270 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3271 (|| -> Result<_, DeserializeError> {
3272 let len = raw.array_sz()?;
3273 let initial_position = raw.as_mut_ref().stream_position().unwrap();
3274 let mut errs = Vec::new();
3275 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
3276 let mut read_len = CBORReadLen::new(len);
3277 read_len.read_elems(4)?;
3278 read_len.finish()?;
3279 let ret = SingleHostAddr::deserialize_as_embedded_group(raw, &mut read_len, len);
3280 match len {
3281 cbor_event::LenSz::Len(_, _) => (),
3282 cbor_event::LenSz::Indefinite => match raw.special()? {
3283 cbor_event::Special::Break => (),
3284 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3285 },
3286 }
3287 ret
3288 })(raw);
3289 match deser_variant {
3290 Ok(single_host_addr) => return Ok(Self::SingleHostAddr(single_host_addr)),
3291 Err(e) => {
3292 errs.push(e.annotate("SingleHostAddr"));
3293 raw.as_mut_ref()
3294 .seek(SeekFrom::Start(initial_position))
3295 .unwrap();
3296 }
3297 };
3298 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
3299 let mut read_len = CBORReadLen::new(len);
3300 read_len.read_elems(3)?;
3301 read_len.finish()?;
3302 let ret =
3303 ShelleySingleHostName::deserialize_as_embedded_group(raw, &mut read_len, len);
3304 match len {
3305 cbor_event::LenSz::Len(_, _) => (),
3306 cbor_event::LenSz::Indefinite => match raw.special()? {
3307 cbor_event::Special::Break => (),
3308 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3309 },
3310 }
3311 ret
3312 })(raw);
3313 match deser_variant {
3314 Ok(shelley_single_host_name) => {
3315 return Ok(Self::ShelleySingleHostName(shelley_single_host_name))
3316 }
3317 Err(e) => {
3318 errs.push(e.annotate("ShelleySingleHostName"));
3319 raw.as_mut_ref()
3320 .seek(SeekFrom::Start(initial_position))
3321 .unwrap();
3322 }
3323 };
3324 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
3325 let mut read_len = CBORReadLen::new(len);
3326 read_len.read_elems(2)?;
3327 read_len.finish()?;
3328 let ret =
3329 ShelleyMultiHostName::deserialize_as_embedded_group(raw, &mut read_len, len);
3330 match len {
3331 cbor_event::LenSz::Len(_, _) => (),
3332 cbor_event::LenSz::Indefinite => match raw.special()? {
3333 cbor_event::Special::Break => (),
3334 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3335 },
3336 }
3337 ret
3338 })(raw);
3339 match deser_variant {
3340 Ok(shelley_multi_host_name) => {
3341 return Ok(Self::ShelleyMultiHostName(shelley_multi_host_name))
3342 }
3343 Err(e) => {
3344 errs.push(e.annotate("ShelleyMultiHostName"));
3345 raw.as_mut_ref()
3346 .seek(SeekFrom::Start(initial_position))
3347 .unwrap();
3348 }
3349 };
3350 Err(DeserializeError::new(
3351 "ShelleyRelay",
3352 DeserializeFailure::NoVariantMatchedWithCauses(errs),
3353 ))
3354 })()
3355 .map_err(|e| e.annotate("ShelleyRelay"))
3356 }
3357}
3358
3359impl Serialize for ShelleySingleHostName {
3360 fn serialize<'se, W: Write>(
3361 &self,
3362 serializer: &'se mut Serializer<W>,
3363 force_canonical: bool,
3364 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3365 serializer.write_array_sz(
3366 self.encodings
3367 .as_ref()
3368 .map(|encs| encs.len_encoding)
3369 .unwrap_or_default()
3370 .to_len_sz(3, force_canonical),
3371 )?;
3372 self.serialize_as_embedded_group(serializer, force_canonical)
3373 }
3374}
3375
3376impl SerializeEmbeddedGroup for ShelleySingleHostName {
3377 fn serialize_as_embedded_group<'se, W: Write>(
3378 &self,
3379 serializer: &'se mut Serializer<W>,
3380 force_canonical: bool,
3381 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3382 serializer.write_unsigned_integer_sz(
3383 1u64,
3384 fit_sz(
3385 1u64,
3386 self.encodings
3387 .as_ref()
3388 .map(|encs| encs.tag_encoding)
3389 .unwrap_or_default(),
3390 force_canonical,
3391 ),
3392 )?;
3393 match &self.port {
3394 Some(x) => serializer.write_unsigned_integer_sz(
3395 *x as u64,
3396 fit_sz(
3397 *x as u64,
3398 self.encodings
3399 .as_ref()
3400 .map(|encs| encs.port_encoding)
3401 .unwrap_or_default(),
3402 force_canonical,
3403 ),
3404 ),
3405 None => serializer.write_special(cbor_event::Special::Null),
3406 }?;
3407 self.shelley_dns_name
3408 .serialize(serializer, force_canonical)?;
3409 self.encodings
3410 .as_ref()
3411 .map(|encs| encs.len_encoding)
3412 .unwrap_or_default()
3413 .end(serializer, force_canonical)
3414 }
3415}
3416
3417impl Deserialize for ShelleySingleHostName {
3418 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3419 let len = raw.array_sz()?;
3420 let mut read_len = CBORReadLen::new(len);
3421 read_len.read_elems(3)?;
3422 read_len.finish()?;
3423 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
3424 match len {
3425 cbor_event::LenSz::Len(_, _) => (),
3426 cbor_event::LenSz::Indefinite => match raw.special()? {
3427 cbor_event::Special::Break => (),
3428 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3429 },
3430 }
3431 ret
3432 }
3433}
3434
3435impl DeserializeEmbeddedGroup for ShelleySingleHostName {
3436 fn deserialize_as_embedded_group<R: BufRead + Seek>(
3437 raw: &mut Deserializer<R>,
3438 _read_len: &mut CBORReadLen,
3439 len: cbor_event::LenSz,
3440 ) -> Result<Self, DeserializeError> {
3441 let len_encoding = len.into();
3442 (|| -> Result<_, DeserializeError> {
3443 let tag_encoding = (|| -> Result<_, DeserializeError> {
3444 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
3445 if tag_value != 1 {
3446 return Err(DeserializeFailure::FixedValueMismatch {
3447 found: Key::Uint(tag_value),
3448 expected: Key::Uint(1),
3449 }
3450 .into());
3451 }
3452 Ok(Some(tag_encoding))
3453 })()
3454 .map_err(|e| e.annotate("tag"))?;
3455 let (port, port_encoding) = (|| -> Result<_, DeserializeError> {
3456 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
3457 true => Result::<_, DeserializeError>::Ok(
3458 raw.unsigned_integer_sz()
3459 .map(|(x, enc)| (x as u16, Some(enc)))?,
3460 )
3461 .map(|(x, port_encoding)| (Some(x), port_encoding))?,
3462 false => {
3463 if raw.special()? != cbor_event::Special::Null {
3464 return Err(DeserializeFailure::ExpectedNull.into());
3465 }
3466 (None, None)
3467 }
3468 })
3469 })()
3470 .map_err(|e| e.annotate("port"))?;
3471 let shelley_dns_name = ShelleyDNSName::deserialize(raw)
3472 .map_err(|e: DeserializeError| e.annotate("shelley__dns_name"))?;
3473 Ok(ShelleySingleHostName {
3474 port,
3475 shelley_dns_name,
3476 encodings: Some(ShelleySingleHostNameEncoding {
3477 len_encoding,
3478 tag_encoding,
3479 port_encoding,
3480 }),
3481 })
3482 })()
3483 .map_err(|e| e.annotate("ShelleySingleHostName"))
3484 }
3485}
3486
3487impl Serialize for ShelleyTransaction {
3488 fn serialize<'se, W: Write>(
3489 &self,
3490 serializer: &'se mut Serializer<W>,
3491 force_canonical: bool,
3492 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3493 serializer.write_array_sz(
3494 self.encodings
3495 .as_ref()
3496 .map(|encs| encs.len_encoding)
3497 .unwrap_or_default()
3498 .to_len_sz(3, force_canonical),
3499 )?;
3500 self.body.serialize(serializer, force_canonical)?;
3501 self.witness_set.serialize(serializer, force_canonical)?;
3502 match &self.metadata {
3503 Some(x) => x.serialize(serializer, force_canonical),
3504 None => serializer.write_special(cbor_event::Special::Null),
3505 }?;
3506 self.encodings
3507 .as_ref()
3508 .map(|encs| encs.len_encoding)
3509 .unwrap_or_default()
3510 .end(serializer, force_canonical)
3511 }
3512}
3513
3514impl Deserialize for ShelleyTransaction {
3515 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3516 let len = raw.array_sz()?;
3517 let len_encoding: LenEncoding = len.into();
3518 let mut read_len = CBORReadLen::new(len);
3519 read_len.read_elems(3)?;
3520 read_len.finish()?;
3521 (|| -> Result<_, DeserializeError> {
3522 let body = ShelleyTransactionBody::deserialize(raw)
3523 .map_err(|e: DeserializeError| e.annotate("body"))?;
3524 let witness_set = ShelleyTransactionWitnessSet::deserialize(raw)
3525 .map_err(|e: DeserializeError| e.annotate("witness_set"))?;
3526 let metadata = (|| -> Result<_, DeserializeError> {
3527 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
3528 true => Some(Metadata::deserialize(raw)?),
3529 false => {
3530 if raw.special()? != cbor_event::Special::Null {
3531 return Err(DeserializeFailure::ExpectedNull.into());
3532 }
3533 None
3534 }
3535 })
3536 })()
3537 .map_err(|e| e.annotate("metadata"))?;
3538 match len {
3539 cbor_event::LenSz::Len(_, _) => (),
3540 cbor_event::LenSz::Indefinite => match raw.special()? {
3541 cbor_event::Special::Break => (),
3542 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3543 },
3544 }
3545 Ok(ShelleyTransaction {
3546 body,
3547 witness_set,
3548 metadata,
3549 encodings: Some(ShelleyTransactionEncoding { len_encoding }),
3550 })
3551 })()
3552 .map_err(|e| e.annotate("ShelleyTransaction"))
3553 }
3554}
3555
3556impl Serialize for ShelleyTransactionBody {
3557 fn serialize<'se, W: Write>(
3558 &self,
3559 serializer: &'se mut Serializer<W>,
3560 force_canonical: bool,
3561 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3562 serializer.write_map_sz(
3563 self.encodings
3564 .as_ref()
3565 .map(|encs| encs.len_encoding)
3566 .unwrap_or_default()
3567 .to_len_sz(
3568 4 + match &self.certs {
3569 Some(_) => 1,
3570 None => 0,
3571 } + match &self.withdrawals {
3572 Some(_) => 1,
3573 None => 0,
3574 } + match &self.update {
3575 Some(_) => 1,
3576 None => 0,
3577 } + match &self.auxiliary_data_hash {
3578 Some(_) => 1,
3579 None => 0,
3580 },
3581 force_canonical,
3582 ),
3583 )?;
3584 let deser_order = self
3585 .encodings
3586 .as_ref()
3587 .filter(|encs| {
3588 !force_canonical
3589 && encs.orig_deser_order.len()
3590 == 4 + match &self.certs {
3591 Some(_) => 1,
3592 None => 0,
3593 } + match &self.withdrawals {
3594 Some(_) => 1,
3595 None => 0,
3596 } + match &self.update {
3597 Some(_) => 1,
3598 None => 0,
3599 } + match &self.auxiliary_data_hash {
3600 Some(_) => 1,
3601 None => 0,
3602 }
3603 })
3604 .map(|encs| encs.orig_deser_order.clone())
3605 .unwrap_or_else(|| vec![0, 1, 2, 3, 4, 5, 6, 7]);
3606 for field_index in deser_order {
3607 match field_index {
3608 0 => {
3609 serializer.write_unsigned_integer_sz(
3610 0u64,
3611 fit_sz(
3612 0u64,
3613 self.encodings
3614 .as_ref()
3615 .map(|encs| encs.inputs_key_encoding)
3616 .unwrap_or_default(),
3617 force_canonical,
3618 ),
3619 )?;
3620 serializer.write_array_sz(
3621 self.encodings
3622 .as_ref()
3623 .map(|encs| encs.inputs_encoding)
3624 .unwrap_or_default()
3625 .to_len_sz(self.inputs.len() as u64, force_canonical),
3626 )?;
3627 for element in self.inputs.iter() {
3628 element.serialize(serializer, force_canonical)?;
3629 }
3630 self.encodings
3631 .as_ref()
3632 .map(|encs| encs.inputs_encoding)
3633 .unwrap_or_default()
3634 .end(serializer, force_canonical)?;
3635 }
3636 1 => {
3637 serializer.write_unsigned_integer_sz(
3638 1u64,
3639 fit_sz(
3640 1u64,
3641 self.encodings
3642 .as_ref()
3643 .map(|encs| encs.outputs_key_encoding)
3644 .unwrap_or_default(),
3645 force_canonical,
3646 ),
3647 )?;
3648 serializer.write_array_sz(
3649 self.encodings
3650 .as_ref()
3651 .map(|encs| encs.outputs_encoding)
3652 .unwrap_or_default()
3653 .to_len_sz(self.outputs.len() as u64, force_canonical),
3654 )?;
3655 for element in self.outputs.iter() {
3656 element.serialize(serializer, force_canonical)?;
3657 }
3658 self.encodings
3659 .as_ref()
3660 .map(|encs| encs.outputs_encoding)
3661 .unwrap_or_default()
3662 .end(serializer, force_canonical)?;
3663 }
3664 2 => {
3665 serializer.write_unsigned_integer_sz(
3666 2u64,
3667 fit_sz(
3668 2u64,
3669 self.encodings
3670 .as_ref()
3671 .map(|encs| encs.fee_key_encoding)
3672 .unwrap_or_default(),
3673 force_canonical,
3674 ),
3675 )?;
3676 serializer.write_unsigned_integer_sz(
3677 self.fee,
3678 fit_sz(
3679 self.fee,
3680 self.encodings
3681 .as_ref()
3682 .map(|encs| encs.fee_encoding)
3683 .unwrap_or_default(),
3684 force_canonical,
3685 ),
3686 )?;
3687 }
3688 3 => {
3689 serializer.write_unsigned_integer_sz(
3690 3u64,
3691 fit_sz(
3692 3u64,
3693 self.encodings
3694 .as_ref()
3695 .map(|encs| encs.ttl_key_encoding)
3696 .unwrap_or_default(),
3697 force_canonical,
3698 ),
3699 )?;
3700 serializer.write_unsigned_integer_sz(
3701 self.ttl,
3702 fit_sz(
3703 self.ttl,
3704 self.encodings
3705 .as_ref()
3706 .map(|encs| encs.ttl_encoding)
3707 .unwrap_or_default(),
3708 force_canonical,
3709 ),
3710 )?;
3711 }
3712 4 => {
3713 if let Some(field) = &self.certs {
3714 serializer.write_unsigned_integer_sz(
3715 4u64,
3716 fit_sz(
3717 4u64,
3718 self.encodings
3719 .as_ref()
3720 .map(|encs| encs.certs_key_encoding)
3721 .unwrap_or_default(),
3722 force_canonical,
3723 ),
3724 )?;
3725 serializer.write_array_sz(
3726 self.encodings
3727 .as_ref()
3728 .map(|encs| encs.certs_encoding)
3729 .unwrap_or_default()
3730 .to_len_sz(field.len() as u64, force_canonical),
3731 )?;
3732 for element in field.iter() {
3733 element.serialize(serializer, force_canonical)?;
3734 }
3735 self.encodings
3736 .as_ref()
3737 .map(|encs| encs.certs_encoding)
3738 .unwrap_or_default()
3739 .end(serializer, force_canonical)?;
3740 }
3741 }
3742 5 => {
3743 if let Some(field) = &self.withdrawals {
3744 serializer.write_unsigned_integer_sz(
3745 5u64,
3746 fit_sz(
3747 5u64,
3748 self.encodings
3749 .as_ref()
3750 .map(|encs| encs.withdrawals_key_encoding)
3751 .unwrap_or_default(),
3752 force_canonical,
3753 ),
3754 )?;
3755 serializer.write_map_sz(
3756 self.encodings
3757 .as_ref()
3758 .map(|encs| encs.withdrawals_encoding)
3759 .unwrap_or_default()
3760 .to_len_sz(field.len() as u64, force_canonical),
3761 )?;
3762 let mut key_order = field
3763 .iter()
3764 .map(|(k, v)| {
3765 let mut buf = cbor_event::se::Serializer::new_vec();
3766 k.serialize(&mut buf, force_canonical)?;
3767 Ok((buf.finalize(), k, v))
3768 })
3769 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
3770 if force_canonical {
3771 key_order.sort_by(
3772 |(lhs_bytes, _, _), (rhs_bytes, _, _)| match lhs_bytes
3773 .len()
3774 .cmp(&rhs_bytes.len())
3775 {
3776 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
3777 diff_ord => diff_ord,
3778 },
3779 );
3780 }
3781 for (key_bytes, key, value) in key_order {
3782 serializer.write_raw_bytes(&key_bytes)?;
3783 let withdrawals_value_encoding = self
3784 .encodings
3785 .as_ref()
3786 .and_then(|encs| encs.withdrawals_value_encodings.get(key))
3787 .cloned()
3788 .unwrap_or_default();
3789 serializer.write_unsigned_integer_sz(
3790 *value,
3791 fit_sz(*value, withdrawals_value_encoding, force_canonical),
3792 )?;
3793 }
3794 self.encodings
3795 .as_ref()
3796 .map(|encs| encs.withdrawals_encoding)
3797 .unwrap_or_default()
3798 .end(serializer, force_canonical)?;
3799 }
3800 }
3801 6 => {
3802 if let Some(field) = &self.update {
3803 serializer.write_unsigned_integer_sz(
3804 6u64,
3805 fit_sz(
3806 6u64,
3807 self.encodings
3808 .as_ref()
3809 .map(|encs| encs.update_key_encoding)
3810 .unwrap_or_default(),
3811 force_canonical,
3812 ),
3813 )?;
3814 field.serialize(serializer, force_canonical)?;
3815 }
3816 }
3817 7 => {
3818 if let Some(field) = &self.auxiliary_data_hash {
3819 serializer.write_unsigned_integer_sz(
3820 7u64,
3821 fit_sz(
3822 7u64,
3823 self.encodings
3824 .as_ref()
3825 .map(|encs| encs.auxiliary_data_hash_key_encoding)
3826 .unwrap_or_default(),
3827 force_canonical,
3828 ),
3829 )?;
3830 serializer.write_bytes_sz(
3831 field.to_raw_bytes(),
3832 self.encodings
3833 .as_ref()
3834 .map(|encs| encs.auxiliary_data_hash_encoding.clone())
3835 .unwrap_or_default()
3836 .to_str_len_sz(field.to_raw_bytes().len() as u64, force_canonical),
3837 )?;
3838 }
3839 }
3840 _ => unreachable!(),
3841 };
3842 }
3843 self.encodings
3844 .as_ref()
3845 .map(|encs| encs.len_encoding)
3846 .unwrap_or_default()
3847 .end(serializer, force_canonical)
3848 }
3849}
3850
3851impl Deserialize for ShelleyTransactionBody {
3852 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3853 let len = raw.map_sz()?;
3854 let len_encoding: LenEncoding = len.into();
3855 let mut read_len = CBORReadLen::new(len);
3856 read_len.read_elems(4)?;
3857 (|| -> Result<_, DeserializeError> {
3858 let mut orig_deser_order = Vec::new();
3859 let mut inputs_encoding = LenEncoding::default();
3860 let mut inputs_key_encoding = None;
3861 let mut inputs = None;
3862 let mut outputs_encoding = LenEncoding::default();
3863 let mut outputs_key_encoding = None;
3864 let mut outputs = None;
3865 let mut fee_encoding = None;
3866 let mut fee_key_encoding = None;
3867 let mut fee = None;
3868 let mut ttl_encoding = None;
3869 let mut ttl_key_encoding = None;
3870 let mut ttl = None;
3871 let mut certs_encoding = LenEncoding::default();
3872 let mut certs_key_encoding = None;
3873 let mut certs = None;
3874 let mut withdrawals_encoding = LenEncoding::default();
3875 let mut withdrawals_value_encodings = BTreeMap::new();
3876 let mut withdrawals_key_encoding = None;
3877 let mut withdrawals = None;
3878 let mut update_key_encoding = None;
3879 let mut update = None;
3880 let mut auxiliary_data_hash_encoding = StringEncoding::default();
3881 let mut auxiliary_data_hash_key_encoding = None;
3882 let mut auxiliary_data_hash = None;
3883 let mut read = 0;
3884 while match len {
3885 cbor_event::LenSz::Len(n, _) => read < n,
3886 cbor_event::LenSz::Indefinite => true,
3887 } {
3888 match raw.cbor_type()? {
3889 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
3890 (0, key_enc) => {
3891 if inputs.is_some() {
3892 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
3893 }
3894 let (tmp_inputs, tmp_inputs_encoding) =
3895 (|| -> Result<_, DeserializeError> {
3896 let mut inputs_arr = Vec::new();
3897 let len = raw.array_sz()?;
3898 let inputs_encoding = len.into();
3899 while match len {
3900 cbor_event::LenSz::Len(n, _) => {
3901 (inputs_arr.len() as u64) < n
3902 }
3903 cbor_event::LenSz::Indefinite => true,
3904 } {
3905 if raw.cbor_type()? == cbor_event::Type::Special {
3906 assert_eq!(raw.special()?, cbor_event::Special::Break);
3907 break;
3908 }
3909 inputs_arr.push(TransactionInput::deserialize(raw)?);
3910 }
3911 Ok((inputs_arr, inputs_encoding))
3912 })()
3913 .map_err(|e| e.annotate("inputs"))?;
3914 inputs = Some(tmp_inputs);
3915 inputs_encoding = tmp_inputs_encoding;
3916 inputs_key_encoding = Some(key_enc);
3917 orig_deser_order.push(0);
3918 }
3919 (1, key_enc) => {
3920 if outputs.is_some() {
3921 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
3922 }
3923 let (tmp_outputs, tmp_outputs_encoding) =
3924 (|| -> Result<_, DeserializeError> {
3925 let mut outputs_arr = Vec::new();
3926 let len = raw.array_sz()?;
3927 let outputs_encoding = len.into();
3928 while match len {
3929 cbor_event::LenSz::Len(n, _) => {
3930 (outputs_arr.len() as u64) < n
3931 }
3932 cbor_event::LenSz::Indefinite => true,
3933 } {
3934 if raw.cbor_type()? == cbor_event::Type::Special {
3935 assert_eq!(raw.special()?, cbor_event::Special::Break);
3936 break;
3937 }
3938 outputs_arr
3939 .push(ShelleyTransactionOutput::deserialize(raw)?);
3940 }
3941 Ok((outputs_arr, outputs_encoding))
3942 })()
3943 .map_err(|e| e.annotate("outputs"))?;
3944 outputs = Some(tmp_outputs);
3945 outputs_encoding = tmp_outputs_encoding;
3946 outputs_key_encoding = Some(key_enc);
3947 orig_deser_order.push(1);
3948 }
3949 (2, key_enc) => {
3950 if fee.is_some() {
3951 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
3952 }
3953 let (tmp_fee, tmp_fee_encoding) = raw
3954 .unsigned_integer_sz()
3955 .map_err(Into::<DeserializeError>::into)
3956 .map(|(x, enc)| (x, Some(enc)))
3957 .map_err(|e: DeserializeError| e.annotate("fee"))?;
3958 fee = Some(tmp_fee);
3959 fee_encoding = tmp_fee_encoding;
3960 fee_key_encoding = Some(key_enc);
3961 orig_deser_order.push(2);
3962 }
3963 (3, key_enc) => {
3964 if ttl.is_some() {
3965 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
3966 }
3967 let (tmp_ttl, tmp_ttl_encoding) = raw
3968 .unsigned_integer_sz()
3969 .map_err(Into::<DeserializeError>::into)
3970 .map(|(x, enc)| (x, Some(enc)))
3971 .map_err(|e: DeserializeError| e.annotate("ttl"))?;
3972 ttl = Some(tmp_ttl);
3973 ttl_encoding = tmp_ttl_encoding;
3974 ttl_key_encoding = Some(key_enc);
3975 orig_deser_order.push(3);
3976 }
3977 (4, key_enc) => {
3978 if certs.is_some() {
3979 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
3980 }
3981 let (tmp_certs, tmp_certs_encoding) =
3982 (|| -> Result<_, DeserializeError> {
3983 read_len.read_elems(1)?;
3984 let mut certs_arr = Vec::new();
3985 let len = raw.array_sz()?;
3986 let certs_encoding = len.into();
3987 while match len {
3988 cbor_event::LenSz::Len(n, _) => {
3989 (certs_arr.len() as u64) < n
3990 }
3991 cbor_event::LenSz::Indefinite => true,
3992 } {
3993 if raw.cbor_type()? == cbor_event::Type::Special {
3994 assert_eq!(raw.special()?, cbor_event::Special::Break);
3995 break;
3996 }
3997 certs_arr.push(ShelleyCertificate::deserialize(raw)?);
3998 }
3999 Ok((certs_arr, certs_encoding))
4000 })()
4001 .map_err(|e| e.annotate("certs"))?;
4002 certs = Some(tmp_certs);
4003 certs_encoding = tmp_certs_encoding;
4004 certs_key_encoding = Some(key_enc);
4005 orig_deser_order.push(4);
4006 }
4007 (5, key_enc) => {
4008 if withdrawals.is_some() {
4009 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
4010 }
4011 let (
4012 tmp_withdrawals,
4013 tmp_withdrawals_encoding,
4014 tmp_withdrawals_value_encodings,
4015 ) = (|| -> Result<_, DeserializeError> {
4016 read_len.read_elems(1)?;
4017 let mut withdrawals_table = OrderedHashMap::new();
4018 let withdrawals_len = raw.map_sz()?;
4019 let withdrawals_encoding = withdrawals_len.into();
4020 let mut withdrawals_value_encodings = BTreeMap::new();
4021 while match withdrawals_len {
4022 cbor_event::LenSz::Len(n, _) => {
4023 (withdrawals_table.len() as u64) < n
4024 }
4025 cbor_event::LenSz::Indefinite => true,
4026 } {
4027 if raw.cbor_type()? == cbor_event::Type::Special {
4028 assert_eq!(raw.special()?, cbor_event::Special::Break);
4029 break;
4030 }
4031 let withdrawals_key = RewardAccount::deserialize(raw)?;
4032 let (withdrawals_value, withdrawals_value_encoding) =
4033 raw.unsigned_integer_sz().map(|(x, enc)| (x, Some(enc)))?;
4034 if withdrawals_table
4035 .insert(withdrawals_key.clone(), withdrawals_value)
4036 .is_some()
4037 {
4038 return Err(DeserializeFailure::DuplicateKey(Key::Str(
4039 String::from("some complicated/unsupported type"),
4040 ))
4041 .into());
4042 }
4043 withdrawals_value_encodings
4044 .insert(withdrawals_key, withdrawals_value_encoding);
4045 }
4046 Ok((
4047 withdrawals_table,
4048 withdrawals_encoding,
4049 withdrawals_value_encodings,
4050 ))
4051 })()
4052 .map_err(|e| e.annotate("withdrawals"))?;
4053 withdrawals = Some(tmp_withdrawals);
4054 withdrawals_encoding = tmp_withdrawals_encoding;
4055 withdrawals_value_encodings = tmp_withdrawals_value_encodings;
4056 withdrawals_key_encoding = Some(key_enc);
4057 orig_deser_order.push(5);
4058 }
4059 (6, key_enc) => {
4060 if update.is_some() {
4061 return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
4062 }
4063 let tmp_update = (|| -> Result<_, DeserializeError> {
4064 read_len.read_elems(1)?;
4065 ShelleyUpdate::deserialize(raw)
4066 })()
4067 .map_err(|e| e.annotate("update"))?;
4068 update = Some(tmp_update);
4069 update_key_encoding = Some(key_enc);
4070 orig_deser_order.push(6);
4071 }
4072 (7, key_enc) => {
4073 if auxiliary_data_hash.is_some() {
4074 return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
4075 }
4076 let (tmp_auxiliary_data_hash, tmp_auxiliary_data_hash_encoding) =
4077 (|| -> Result<_, DeserializeError> {
4078 read_len.read_elems(1)?;
4079 raw.bytes_sz()
4080 .map_err(Into::<DeserializeError>::into)
4081 .and_then(|(bytes, enc)| {
4082 AuxiliaryDataHash::from_raw_bytes(&bytes)
4083 .map(|bytes| (bytes, StringEncoding::from(enc)))
4084 .map_err(|e| {
4085 DeserializeFailure::InvalidStructure(Box::new(
4086 e,
4087 ))
4088 .into()
4089 })
4090 })
4091 })()
4092 .map_err(|e| e.annotate("auxiliary_data_hash"))?;
4093 auxiliary_data_hash = Some(tmp_auxiliary_data_hash);
4094 auxiliary_data_hash_encoding = tmp_auxiliary_data_hash_encoding;
4095 auxiliary_data_hash_key_encoding = Some(key_enc);
4096 orig_deser_order.push(7);
4097 }
4098 (unknown_key, _enc) => {
4099 return Err(
4100 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
4101 )
4102 }
4103 },
4104 cbor_event::Type::Text => {
4105 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
4106 }
4107 cbor_event::Type::Special => match len {
4108 cbor_event::LenSz::Len(_, _) => {
4109 return Err(DeserializeFailure::BreakInDefiniteLen.into())
4110 }
4111 cbor_event::LenSz::Indefinite => match raw.special()? {
4112 cbor_event::Special::Break => break,
4113 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
4114 },
4115 },
4116 other_type => {
4117 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
4118 }
4119 }
4120 read += 1;
4121 }
4122 let inputs = match inputs {
4123 Some(x) => x,
4124 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(0)).into()),
4125 };
4126 let outputs = match outputs {
4127 Some(x) => x,
4128 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
4129 };
4130 let fee = match fee {
4131 Some(x) => x,
4132 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(2)).into()),
4133 };
4134 let ttl = match ttl {
4135 Some(x) => x,
4136 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(3)).into()),
4137 };
4138 read_len.finish()?;
4139 Ok(Self {
4140 inputs,
4141 outputs,
4142 fee,
4143 ttl,
4144 certs,
4145 withdrawals,
4146 update,
4147 auxiliary_data_hash,
4148 encodings: Some(ShelleyTransactionBodyEncoding {
4149 len_encoding,
4150 orig_deser_order,
4151 inputs_key_encoding,
4152 inputs_encoding,
4153 outputs_key_encoding,
4154 outputs_encoding,
4155 fee_key_encoding,
4156 fee_encoding,
4157 ttl_key_encoding,
4158 ttl_encoding,
4159 certs_key_encoding,
4160 certs_encoding,
4161 withdrawals_key_encoding,
4162 withdrawals_encoding,
4163 withdrawals_value_encodings,
4164 update_key_encoding,
4165 auxiliary_data_hash_key_encoding,
4166 auxiliary_data_hash_encoding,
4167 }),
4168 })
4169 })()
4170 .map_err(|e| e.annotate("ShelleyTransactionBody"))
4171 }
4172}
4173
4174impl Serialize for ShelleyTransactionOutput {
4175 fn serialize<'se, W: Write>(
4176 &self,
4177 serializer: &'se mut Serializer<W>,
4178 force_canonical: bool,
4179 ) -> cbor_event::Result<&'se mut Serializer<W>> {
4180 serializer.write_array_sz(
4181 self.encodings
4182 .as_ref()
4183 .map(|encs| encs.len_encoding)
4184 .unwrap_or_default()
4185 .to_len_sz(2, force_canonical),
4186 )?;
4187 self.address.serialize(serializer, force_canonical)?;
4188 serializer.write_unsigned_integer_sz(
4189 self.amount,
4190 fit_sz(
4191 self.amount,
4192 self.encodings
4193 .as_ref()
4194 .map(|encs| encs.amount_encoding)
4195 .unwrap_or_default(),
4196 force_canonical,
4197 ),
4198 )?;
4199 self.encodings
4200 .as_ref()
4201 .map(|encs| encs.len_encoding)
4202 .unwrap_or_default()
4203 .end(serializer, force_canonical)
4204 }
4205}
4206
4207impl Deserialize for ShelleyTransactionOutput {
4208 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
4209 let len = raw.array_sz()?;
4210 let len_encoding: LenEncoding = len.into();
4211 let mut read_len = CBORReadLen::new(len);
4212 read_len.read_elems(2)?;
4213 read_len.finish()?;
4214 (|| -> Result<_, DeserializeError> {
4215 let address =
4216 Address::deserialize(raw).map_err(|e: DeserializeError| e.annotate("address"))?;
4217 let (amount, amount_encoding) = raw
4218 .unsigned_integer_sz()
4219 .map_err(Into::<DeserializeError>::into)
4220 .map(|(x, enc)| (x, Some(enc)))
4221 .map_err(|e: DeserializeError| e.annotate("amount"))?;
4222 match len {
4223 cbor_event::LenSz::Len(_, _) => (),
4224 cbor_event::LenSz::Indefinite => match raw.special()? {
4225 cbor_event::Special::Break => (),
4226 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
4227 },
4228 }
4229 Ok(ShelleyTransactionOutput {
4230 address,
4231 amount,
4232 encodings: Some(ShelleyTransactionOutputEncoding {
4233 len_encoding,
4234 amount_encoding,
4235 }),
4236 })
4237 })()
4238 .map_err(|e| e.annotate("ShelleyTransactionOutput"))
4239 }
4240}
4241
4242impl Serialize for ShelleyTransactionWitnessSet {
4243 fn serialize<'se, W: Write>(
4244 &self,
4245 serializer: &'se mut Serializer<W>,
4246 force_canonical: bool,
4247 ) -> cbor_event::Result<&'se mut Serializer<W>> {
4248 serializer.write_map_sz(
4249 self.encodings
4250 .as_ref()
4251 .map(|encs| encs.len_encoding)
4252 .unwrap_or_default()
4253 .to_len_sz(
4254 match &self.vkeywitnesses {
4255 Some(_) => 1,
4256 None => 0,
4257 } + match &self.native_scripts {
4258 Some(_) => 1,
4259 None => 0,
4260 } + match &self.bootstrap_witnesses {
4261 Some(_) => 1,
4262 None => 0,
4263 },
4264 force_canonical,
4265 ),
4266 )?;
4267 let deser_order = self
4268 .encodings
4269 .as_ref()
4270 .filter(|encs| {
4271 !force_canonical
4272 && encs.orig_deser_order.len()
4273 == match &self.vkeywitnesses {
4274 Some(_) => 1,
4275 None => 0,
4276 } + match &self.native_scripts {
4277 Some(_) => 1,
4278 None => 0,
4279 } + match &self.bootstrap_witnesses {
4280 Some(_) => 1,
4281 None => 0,
4282 }
4283 })
4284 .map(|encs| encs.orig_deser_order.clone())
4285 .unwrap_or_else(|| vec![0, 1, 2]);
4286 for field_index in deser_order {
4287 match field_index {
4288 0 => {
4289 if let Some(field) = &self.vkeywitnesses {
4290 serializer.write_unsigned_integer_sz(
4291 0u64,
4292 fit_sz(
4293 0u64,
4294 self.encodings
4295 .as_ref()
4296 .map(|encs| encs.vkeywitnesses_key_encoding)
4297 .unwrap_or_default(),
4298 force_canonical,
4299 ),
4300 )?;
4301 serializer.write_array_sz(
4302 self.encodings
4303 .as_ref()
4304 .map(|encs| encs.vkeywitnesses_encoding)
4305 .unwrap_or_default()
4306 .to_len_sz(field.len() as u64, force_canonical),
4307 )?;
4308 for element in field.iter() {
4309 element.serialize(serializer, force_canonical)?;
4310 }
4311 self.encodings
4312 .as_ref()
4313 .map(|encs| encs.vkeywitnesses_encoding)
4314 .unwrap_or_default()
4315 .end(serializer, force_canonical)?;
4316 }
4317 }
4318 1 => {
4319 if let Some(field) = &self.native_scripts {
4320 serializer.write_unsigned_integer_sz(
4321 1u64,
4322 fit_sz(
4323 1u64,
4324 self.encodings
4325 .as_ref()
4326 .map(|encs| encs.native_scripts_key_encoding)
4327 .unwrap_or_default(),
4328 force_canonical,
4329 ),
4330 )?;
4331 serializer.write_array_sz(
4332 self.encodings
4333 .as_ref()
4334 .map(|encs| encs.native_scripts_encoding)
4335 .unwrap_or_default()
4336 .to_len_sz(field.len() as u64, force_canonical),
4337 )?;
4338 for element in field.iter() {
4339 element.serialize(serializer, force_canonical)?;
4340 }
4341 self.encodings
4342 .as_ref()
4343 .map(|encs| encs.native_scripts_encoding)
4344 .unwrap_or_default()
4345 .end(serializer, force_canonical)?;
4346 }
4347 }
4348 2 => {
4349 if let Some(field) = &self.bootstrap_witnesses {
4350 serializer.write_unsigned_integer_sz(
4351 2u64,
4352 fit_sz(
4353 2u64,
4354 self.encodings
4355 .as_ref()
4356 .map(|encs| encs.bootstrap_witnesses_key_encoding)
4357 .unwrap_or_default(),
4358 force_canonical,
4359 ),
4360 )?;
4361 serializer.write_array_sz(
4362 self.encodings
4363 .as_ref()
4364 .map(|encs| encs.bootstrap_witnesses_encoding)
4365 .unwrap_or_default()
4366 .to_len_sz(field.len() as u64, force_canonical),
4367 )?;
4368 for element in field.iter() {
4369 element.serialize(serializer, force_canonical)?;
4370 }
4371 self.encodings
4372 .as_ref()
4373 .map(|encs| encs.bootstrap_witnesses_encoding)
4374 .unwrap_or_default()
4375 .end(serializer, force_canonical)?;
4376 }
4377 }
4378 _ => unreachable!(),
4379 };
4380 }
4381 self.encodings
4382 .as_ref()
4383 .map(|encs| encs.len_encoding)
4384 .unwrap_or_default()
4385 .end(serializer, force_canonical)
4386 }
4387}
4388
4389impl Deserialize for ShelleyTransactionWitnessSet {
4390 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
4391 let len = raw.map_sz()?;
4392 let len_encoding: LenEncoding = len.into();
4393 let mut read_len = CBORReadLen::new(len);
4394 (|| -> Result<_, DeserializeError> {
4395 let mut orig_deser_order = Vec::new();
4396 let mut vkeywitnesses_encoding = LenEncoding::default();
4397 let mut vkeywitnesses_key_encoding = None;
4398 let mut vkeywitnesses = None;
4399 let mut native_scripts_encoding = LenEncoding::default();
4400 let mut native_scripts_key_encoding = None;
4401 let mut native_scripts = None;
4402 let mut bootstrap_witnesses_encoding = LenEncoding::default();
4403 let mut bootstrap_witnesses_key_encoding = None;
4404 let mut bootstrap_witnesses = None;
4405 let mut read = 0;
4406 while match len {
4407 cbor_event::LenSz::Len(n, _) => read < n,
4408 cbor_event::LenSz::Indefinite => true,
4409 } {
4410 match raw.cbor_type()? {
4411 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
4412 (0, key_enc) => {
4413 if vkeywitnesses.is_some() {
4414 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
4415 }
4416 let (tmp_vkeywitnesses, tmp_vkeywitnesses_encoding) =
4417 (|| -> Result<_, DeserializeError> {
4418 read_len.read_elems(1)?;
4419 let mut vkeywitnesses_arr = Vec::new();
4420 let len = raw.array_sz()?;
4421 let vkeywitnesses_encoding = len.into();
4422 while match len {
4423 cbor_event::LenSz::Len(n, _) => {
4424 (vkeywitnesses_arr.len() as u64) < n
4425 }
4426 cbor_event::LenSz::Indefinite => true,
4427 } {
4428 if raw.cbor_type()? == cbor_event::Type::Special {
4429 assert_eq!(raw.special()?, cbor_event::Special::Break);
4430 break;
4431 }
4432 vkeywitnesses_arr.push(Vkeywitness::deserialize(raw)?);
4433 }
4434 Ok((vkeywitnesses_arr, vkeywitnesses_encoding))
4435 })()
4436 .map_err(|e| e.annotate("vkeywitnesses"))?;
4437 vkeywitnesses = Some(tmp_vkeywitnesses);
4438 vkeywitnesses_encoding = tmp_vkeywitnesses_encoding;
4439 vkeywitnesses_key_encoding = Some(key_enc);
4440 orig_deser_order.push(0);
4441 }
4442 (1, key_enc) => {
4443 if native_scripts.is_some() {
4444 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
4445 }
4446 let (tmp_native_scripts, tmp_native_scripts_encoding) =
4447 (|| -> Result<_, DeserializeError> {
4448 read_len.read_elems(1)?;
4449 let mut native_scripts_arr = Vec::new();
4450 let len = raw.array_sz()?;
4451 let native_scripts_encoding = len.into();
4452 while match len {
4453 cbor_event::LenSz::Len(n, _) => {
4454 (native_scripts_arr.len() as u64) < n
4455 }
4456 cbor_event::LenSz::Indefinite => true,
4457 } {
4458 if raw.cbor_type()? == cbor_event::Type::Special {
4459 assert_eq!(raw.special()?, cbor_event::Special::Break);
4460 break;
4461 }
4462 native_scripts_arr.push(MultisigScript::deserialize(raw)?);
4463 }
4464 Ok((native_scripts_arr, native_scripts_encoding))
4465 })()
4466 .map_err(|e| e.annotate("native_scripts"))?;
4467 native_scripts = Some(tmp_native_scripts);
4468 native_scripts_encoding = tmp_native_scripts_encoding;
4469 native_scripts_key_encoding = Some(key_enc);
4470 orig_deser_order.push(1);
4471 }
4472 (2, key_enc) => {
4473 if bootstrap_witnesses.is_some() {
4474 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
4475 }
4476 let (tmp_bootstrap_witnesses, tmp_bootstrap_witnesses_encoding) =
4477 (|| -> Result<_, DeserializeError> {
4478 read_len.read_elems(1)?;
4479 let mut bootstrap_witnesses_arr = Vec::new();
4480 let len = raw.array_sz()?;
4481 let bootstrap_witnesses_encoding = len.into();
4482 while match len {
4483 cbor_event::LenSz::Len(n, _) => {
4484 (bootstrap_witnesses_arr.len() as u64) < n
4485 }
4486 cbor_event::LenSz::Indefinite => true,
4487 } {
4488 if raw.cbor_type()? == cbor_event::Type::Special {
4489 assert_eq!(raw.special()?, cbor_event::Special::Break);
4490 break;
4491 }
4492 bootstrap_witnesses_arr
4493 .push(BootstrapWitness::deserialize(raw)?);
4494 }
4495 Ok((bootstrap_witnesses_arr, bootstrap_witnesses_encoding))
4496 })()
4497 .map_err(|e| e.annotate("bootstrap_witnesses"))?;
4498 bootstrap_witnesses = Some(tmp_bootstrap_witnesses);
4499 bootstrap_witnesses_encoding = tmp_bootstrap_witnesses_encoding;
4500 bootstrap_witnesses_key_encoding = Some(key_enc);
4501 orig_deser_order.push(2);
4502 }
4503 (unknown_key, _enc) => {
4504 return Err(
4505 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
4506 )
4507 }
4508 },
4509 cbor_event::Type::Text => {
4510 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
4511 }
4512 cbor_event::Type::Special => match len {
4513 cbor_event::LenSz::Len(_, _) => {
4514 return Err(DeserializeFailure::BreakInDefiniteLen.into())
4515 }
4516 cbor_event::LenSz::Indefinite => match raw.special()? {
4517 cbor_event::Special::Break => break,
4518 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
4519 },
4520 },
4521 other_type => {
4522 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
4523 }
4524 }
4525 read += 1;
4526 }
4527 read_len.finish()?;
4528 Ok(Self {
4529 vkeywitnesses,
4530 native_scripts,
4531 bootstrap_witnesses,
4532 encodings: Some(ShelleyTransactionWitnessSetEncoding {
4533 len_encoding,
4534 orig_deser_order,
4535 vkeywitnesses_key_encoding,
4536 vkeywitnesses_encoding,
4537 native_scripts_key_encoding,
4538 native_scripts_encoding,
4539 bootstrap_witnesses_key_encoding,
4540 bootstrap_witnesses_encoding,
4541 }),
4542 })
4543 })()
4544 .map_err(|e| e.annotate("ShelleyTransactionWitnessSet"))
4545 }
4546}
4547
4548impl Serialize for ShelleyUpdate {
4549 fn serialize<'se, W: Write>(
4550 &self,
4551 serializer: &'se mut Serializer<W>,
4552 force_canonical: bool,
4553 ) -> cbor_event::Result<&'se mut Serializer<W>> {
4554 serializer.write_array_sz(
4555 self.encodings
4556 .as_ref()
4557 .map(|encs| encs.len_encoding)
4558 .unwrap_or_default()
4559 .to_len_sz(2, force_canonical),
4560 )?;
4561 serializer.write_map_sz(
4562 self.encodings
4563 .as_ref()
4564 .map(|encs| encs.shelley_proposed_protocol_parameter_updates_encoding)
4565 .unwrap_or_default()
4566 .to_len_sz(
4567 self.shelley_proposed_protocol_parameter_updates.len() as u64,
4568 force_canonical,
4569 ),
4570 )?;
4571 let mut key_order = self
4572 .shelley_proposed_protocol_parameter_updates
4573 .iter()
4574 .map(|(k, v)| {
4575 let mut buf = cbor_event::se::Serializer::new_vec();
4576 let shelley_proposed_protocol_parameter_updates_key_encoding = self
4577 .encodings
4578 .as_ref()
4579 .and_then(|encs| {
4580 encs.shelley_proposed_protocol_parameter_updates_key_encodings
4581 .get(k)
4582 })
4583 .cloned()
4584 .unwrap_or_default();
4585 buf.write_bytes_sz(
4586 k.to_raw_bytes(),
4587 shelley_proposed_protocol_parameter_updates_key_encoding
4588 .to_str_len_sz(k.to_raw_bytes().len() as u64, force_canonical),
4589 )?;
4590 Ok((buf.finalize(), k, v))
4591 })
4592 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
4593 if force_canonical {
4594 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
4595 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
4596 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
4597 diff_ord => diff_ord,
4598 }
4599 });
4600 }
4601 for (key_bytes, _key, value) in key_order {
4602 serializer.write_raw_bytes(&key_bytes)?;
4603 value.serialize(serializer, force_canonical)?;
4604 }
4605 self.encodings
4606 .as_ref()
4607 .map(|encs| encs.shelley_proposed_protocol_parameter_updates_encoding)
4608 .unwrap_or_default()
4609 .end(serializer, force_canonical)?;
4610 serializer.write_unsigned_integer_sz(
4611 self.epoch,
4612 fit_sz(
4613 self.epoch,
4614 self.encodings
4615 .as_ref()
4616 .map(|encs| encs.epoch_encoding)
4617 .unwrap_or_default(),
4618 force_canonical,
4619 ),
4620 )?;
4621 self.encodings
4622 .as_ref()
4623 .map(|encs| encs.len_encoding)
4624 .unwrap_or_default()
4625 .end(serializer, force_canonical)
4626 }
4627}
4628
4629impl Deserialize for ShelleyUpdate {
4630 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
4631 let len = raw.array_sz()?;
4632 let len_encoding: LenEncoding = len.into();
4633 let mut read_len = CBORReadLen::new(len);
4634 read_len.read_elems(2)?;
4635 read_len.finish()?;
4636 (|| -> Result<_, DeserializeError> {
4637 let (
4638 shelley_proposed_protocol_parameter_updates,
4639 shelley_proposed_protocol_parameter_updates_encoding,
4640 shelley_proposed_protocol_parameter_updates_key_encodings,
4641 ) = (|| -> Result<_, DeserializeError> {
4642 let mut shelley_proposed_protocol_parameter_updates_table = OrderedHashMap::new();
4643 let shelley_proposed_protocol_parameter_updates_len = raw.map_sz()?;
4644 let shelley_proposed_protocol_parameter_updates_encoding =
4645 shelley_proposed_protocol_parameter_updates_len.into();
4646 let mut shelley_proposed_protocol_parameter_updates_key_encodings = BTreeMap::new();
4647 while match shelley_proposed_protocol_parameter_updates_len {
4648 cbor_event::LenSz::Len(n, _) => {
4649 (shelley_proposed_protocol_parameter_updates_table.len() as u64) < n
4650 }
4651 cbor_event::LenSz::Indefinite => true,
4652 } {
4653 if raw.cbor_type()? == cbor_event::Type::Special {
4654 assert_eq!(raw.special()?, cbor_event::Special::Break);
4655 break;
4656 }
4657 let (
4658 shelley_proposed_protocol_parameter_updates_key,
4659 shelley_proposed_protocol_parameter_updates_key_encoding,
4660 ) = raw
4661 .bytes_sz()
4662 .map_err(Into::<DeserializeError>::into)
4663 .and_then(|(bytes, enc)| {
4664 GenesisHash::from_raw_bytes(&bytes)
4665 .map(|bytes| (bytes, StringEncoding::from(enc)))
4666 .map_err(|e| {
4667 DeserializeFailure::InvalidStructure(Box::new(e)).into()
4668 })
4669 })?;
4670 let shelley_proposed_protocol_parameter_updates_value =
4671 ShelleyProtocolParamUpdate::deserialize(raw)?;
4672 if shelley_proposed_protocol_parameter_updates_table
4673 .insert(
4674 shelley_proposed_protocol_parameter_updates_key,
4675 shelley_proposed_protocol_parameter_updates_value,
4676 )
4677 .is_some()
4678 {
4679 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
4680 "some complicated/unsupported type",
4681 )))
4682 .into());
4683 }
4684 shelley_proposed_protocol_parameter_updates_key_encodings.insert(
4685 shelley_proposed_protocol_parameter_updates_key,
4686 shelley_proposed_protocol_parameter_updates_key_encoding,
4687 );
4688 }
4689 Ok((
4690 shelley_proposed_protocol_parameter_updates_table,
4691 shelley_proposed_protocol_parameter_updates_encoding,
4692 shelley_proposed_protocol_parameter_updates_key_encodings,
4693 ))
4694 })()
4695 .map_err(|e| e.annotate("shelley_proposed_protocol_parameter_updates"))?;
4696 let (epoch, epoch_encoding) = raw
4697 .unsigned_integer_sz()
4698 .map_err(Into::<DeserializeError>::into)
4699 .map(|(x, enc)| (x, Some(enc)))
4700 .map_err(|e: DeserializeError| e.annotate("epoch"))?;
4701 match len {
4702 cbor_event::LenSz::Len(_, _) => (),
4703 cbor_event::LenSz::Indefinite => match raw.special()? {
4704 cbor_event::Special::Break => (),
4705 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
4706 },
4707 }
4708 Ok(ShelleyUpdate {
4709 shelley_proposed_protocol_parameter_updates,
4710 epoch,
4711 encodings: Some(ShelleyUpdateEncoding {
4712 len_encoding,
4713 shelley_proposed_protocol_parameter_updates_encoding,
4714 shelley_proposed_protocol_parameter_updates_key_encodings,
4715 epoch_encoding,
4716 }),
4717 })
4718 })()
4719 .map_err(|e| e.annotate("ShelleyUpdate"))
4720 }
4721}