1use crate::certs::Credential;
5
6use super::cbor_encodings::*;
7use super::*;
8use cbor_event::de::Deserializer;
9use cbor_event::se::Serializer;
10use cml_core::error::*;
11use cml_core::serialization::*;
12use cml_crypto::AnchorDocHash;
13use cml_crypto::RawBytesEncoding;
14use std::io::{BufRead, Seek, SeekFrom, Write};
15
16impl Serialize for Anchor {
17 fn serialize<'se, W: Write>(
18 &self,
19 serializer: &'se mut Serializer<W>,
20 force_canonical: bool,
21 ) -> cbor_event::Result<&'se mut Serializer<W>> {
22 serializer.write_array_sz(
23 self.encodings
24 .as_ref()
25 .map(|encs| encs.len_encoding)
26 .unwrap_or_default()
27 .to_len_sz(2, force_canonical),
28 )?;
29 self.anchor_url.serialize(serializer, force_canonical)?;
30 serializer.write_bytes_sz(
31 self.anchor_doc_hash.to_raw_bytes(),
32 self.encodings
33 .as_ref()
34 .map(|encs| encs.anchor_doc_hash_encoding.clone())
35 .unwrap_or_default()
36 .to_str_len_sz(
37 self.anchor_doc_hash.to_raw_bytes().len() as u64,
38 force_canonical,
39 ),
40 )?;
41 self.encodings
42 .as_ref()
43 .map(|encs| encs.len_encoding)
44 .unwrap_or_default()
45 .end(serializer, force_canonical)
46 }
47}
48
49impl Deserialize for Anchor {
50 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
51 let len = raw.array_sz()?;
52 let len_encoding: LenEncoding = len.into();
53 let mut read_len = CBORReadLen::new(len);
54 read_len.read_elems(2)?;
55 read_len.finish()?;
56 (|| -> Result<_, DeserializeError> {
57 let anchor_url =
58 Url::deserialize(raw).map_err(|e: DeserializeError| e.annotate("anchor_url"))?;
59 let (anchor_doc_hash, anchor_doc_hash_encoding) = raw
60 .bytes_sz()
61 .map_err(Into::<DeserializeError>::into)
62 .and_then(|(bytes, enc)| {
63 AnchorDocHash::from_raw_bytes(&bytes)
64 .map(|bytes| (bytes, StringEncoding::from(enc)))
65 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
66 })
67 .map_err(|e: DeserializeError| e.annotate("anchor_doc_hash"))?;
68 match len {
69 cbor_event::LenSz::Len(_, _) => (),
70 cbor_event::LenSz::Indefinite => match raw.special()? {
71 cbor_event::Special::Break => (),
72 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
73 },
74 }
75 Ok(Anchor {
76 anchor_url,
77 anchor_doc_hash,
78 encodings: Some(AnchorEncoding {
79 len_encoding,
80 anchor_doc_hash_encoding,
81 }),
82 })
83 })()
84 .map_err(|e| e.annotate("Anchor"))
85 }
86}
87
88impl Serialize for Constitution {
89 fn serialize<'se, W: Write>(
90 &self,
91 serializer: &'se mut Serializer<W>,
92 force_canonical: bool,
93 ) -> cbor_event::Result<&'se mut Serializer<W>> {
94 serializer.write_array_sz(
95 self.encodings
96 .as_ref()
97 .map(|encs| encs.len_encoding)
98 .unwrap_or_default()
99 .to_len_sz(2, force_canonical),
100 )?;
101 self.anchor.serialize(serializer, force_canonical)?;
102 match &self.script_hash {
103 Some(x) => serializer.write_bytes_sz(
104 x.to_raw_bytes(),
105 self.encodings
106 .as_ref()
107 .map(|encs| encs.script_hash_encoding.clone())
108 .unwrap_or_default()
109 .to_str_len_sz(x.to_raw_bytes().len() as u64, force_canonical),
110 ),
111 None => serializer.write_special(cbor_event::Special::Null),
112 }?;
113 self.encodings
114 .as_ref()
115 .map(|encs| encs.len_encoding)
116 .unwrap_or_default()
117 .end(serializer, force_canonical)
118 }
119}
120
121impl Deserialize for Constitution {
122 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
123 let len = raw.array_sz()?;
124 let len_encoding: LenEncoding = len.into();
125 let mut read_len = CBORReadLen::new(len);
126 read_len.read_elems(2)?;
127 read_len.finish()?;
128 (|| -> Result<_, DeserializeError> {
129 let anchor =
130 Anchor::deserialize(raw).map_err(|e: DeserializeError| e.annotate("anchor"))?;
131 let (script_hash, script_hash_encoding) = (|| -> Result<_, DeserializeError> {
132 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
133 true => Result::<_, DeserializeError>::Ok(
134 raw.bytes_sz()
135 .map_err(Into::<DeserializeError>::into)
136 .and_then(|(bytes, enc)| {
137 ScriptHash::from_raw_bytes(&bytes)
138 .map(|bytes| (bytes, StringEncoding::from(enc)))
139 .map_err(|e| {
140 DeserializeFailure::InvalidStructure(Box::new(e)).into()
141 })
142 })?,
143 )
144 .map(|(x, script_hash_encoding)| (Some(x), script_hash_encoding))?,
145 false => {
146 if raw.special()? != cbor_event::Special::Null {
147 return Err(DeserializeFailure::ExpectedNull.into());
148 }
149 (None, StringEncoding::default())
150 }
151 })
152 })()
153 .map_err(|e| e.annotate("script_hash"))?;
154 match len {
155 cbor_event::LenSz::Len(_, _) => (),
156 cbor_event::LenSz::Indefinite => match raw.special()? {
157 cbor_event::Special::Break => (),
158 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
159 },
160 }
161 Ok(Constitution {
162 anchor,
163 script_hash,
164 encodings: Some(ConstitutionEncoding {
165 len_encoding,
166 script_hash_encoding,
167 }),
168 })
169 })()
170 .map_err(|e| e.annotate("Constitution"))
171 }
172}
173
174impl Serialize for GovAction {
175 fn serialize<'se, W: Write>(
176 &self,
177 serializer: &'se mut Serializer<W>,
178 force_canonical: bool,
179 ) -> cbor_event::Result<&'se mut Serializer<W>> {
180 match self {
181 GovAction::ParameterChangeAction(parameter_change_action) => {
182 parameter_change_action.serialize(serializer, force_canonical)
183 }
184 GovAction::HardForkInitiationAction(hard_fork_initiation_action) => {
185 hard_fork_initiation_action.serialize(serializer, force_canonical)
186 }
187 GovAction::TreasuryWithdrawalsAction(treasury_withdrawals_action) => {
188 treasury_withdrawals_action.serialize(serializer, force_canonical)
189 }
190 GovAction::NoConfidence(no_confidence) => {
191 no_confidence.serialize(serializer, force_canonical)
192 }
193 GovAction::UpdateCommittee(update_committee) => {
194 update_committee.serialize(serializer, force_canonical)
195 }
196 GovAction::NewConstitution(new_constitution) => {
197 new_constitution.serialize(serializer, force_canonical)
198 }
199 GovAction::InfoAction {
200 info_action_encoding,
201 len_encoding,
202 } => {
203 serializer.write_array_sz(len_encoding.to_len_sz(1, force_canonical))?;
204 serializer.write_unsigned_integer_sz(
205 6u64,
206 fit_sz(6u64, *info_action_encoding, force_canonical),
207 )?;
208 len_encoding.end(serializer, force_canonical)?;
209 Ok(serializer)
210 }
211 }
212 }
213}
214
215impl Deserialize for GovAction {
216 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
217 (|| -> Result<_, DeserializeError> {
218 let len = raw.array_sz()?;
219 let len_encoding: LenEncoding = len.into();
220 let initial_position = raw.as_mut_ref().stream_position().unwrap();
221 let mut errs = Vec::new();
222 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
223 let mut read_len = CBORReadLen::new(len);
224 read_len.read_elems(4)?;
225 read_len.finish()?;
226 let ret =
227 ParameterChangeAction::deserialize_as_embedded_group(raw, &mut read_len, len);
228 match len {
229 cbor_event::LenSz::Len(_, _) => (),
230 cbor_event::LenSz::Indefinite => match raw.special()? {
231 cbor_event::Special::Break => (),
232 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
233 },
234 }
235 ret
236 })(raw);
237 match deser_variant {
238 Ok(parameter_change_action) => {
239 return Ok(Self::ParameterChangeAction(parameter_change_action))
240 }
241 Err(e) => {
242 errs.push(e.annotate("ParameterChangeAction"));
243 raw.as_mut_ref()
244 .seek(SeekFrom::Start(initial_position))
245 .unwrap();
246 }
247 };
248 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
249 let mut read_len = CBORReadLen::new(len);
250 read_len.read_elems(3)?;
251 read_len.finish()?;
252 let ret = HardForkInitiationAction::deserialize_as_embedded_group(
253 raw,
254 &mut read_len,
255 len,
256 );
257 match len {
258 cbor_event::LenSz::Len(_, _) => (),
259 cbor_event::LenSz::Indefinite => match raw.special()? {
260 cbor_event::Special::Break => (),
261 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
262 },
263 }
264 ret
265 })(raw);
266 match deser_variant {
267 Ok(hard_fork_initiation_action) => {
268 return Ok(Self::HardForkInitiationAction(hard_fork_initiation_action))
269 }
270 Err(e) => {
271 errs.push(e.annotate("HardForkInitiationAction"));
272 raw.as_mut_ref()
273 .seek(SeekFrom::Start(initial_position))
274 .unwrap();
275 }
276 };
277 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
278 let mut read_len = CBORReadLen::new(len);
279 read_len.read_elems(3)?;
280 read_len.finish()?;
281 let ret = TreasuryWithdrawalsAction::deserialize_as_embedded_group(
282 raw,
283 &mut read_len,
284 len,
285 );
286 match len {
287 cbor_event::LenSz::Len(_, _) => (),
288 cbor_event::LenSz::Indefinite => match raw.special()? {
289 cbor_event::Special::Break => (),
290 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
291 },
292 }
293 ret
294 })(raw);
295 match deser_variant {
296 Ok(treasury_withdrawals_action) => {
297 return Ok(Self::TreasuryWithdrawalsAction(treasury_withdrawals_action))
298 }
299 Err(e) => {
300 errs.push(e.annotate("TreasuryWithdrawalsAction"));
301 raw.as_mut_ref()
302 .seek(SeekFrom::Start(initial_position))
303 .unwrap();
304 }
305 };
306 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
307 let mut read_len = CBORReadLen::new(len);
308 read_len.read_elems(2)?;
309 read_len.finish()?;
310 let ret = NoConfidence::deserialize_as_embedded_group(raw, &mut read_len, len);
311 match len {
312 cbor_event::LenSz::Len(_, _) => (),
313 cbor_event::LenSz::Indefinite => match raw.special()? {
314 cbor_event::Special::Break => (),
315 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
316 },
317 }
318 ret
319 })(raw);
320 match deser_variant {
321 Ok(no_confidence) => return Ok(Self::NoConfidence(no_confidence)),
322 Err(e) => {
323 errs.push(e.annotate("NoConfidence"));
324 raw.as_mut_ref()
325 .seek(SeekFrom::Start(initial_position))
326 .unwrap();
327 }
328 };
329 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
330 let mut read_len = CBORReadLen::new(len);
331 read_len.read_elems(5)?;
332 read_len.finish()?;
333 let ret = UpdateCommittee::deserialize_as_embedded_group(raw, &mut read_len, len);
334 match len {
335 cbor_event::LenSz::Len(_, _) => (),
336 cbor_event::LenSz::Indefinite => match raw.special()? {
337 cbor_event::Special::Break => (),
338 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
339 },
340 }
341 ret
342 })(raw);
343 match deser_variant {
344 Ok(update_committee) => return Ok(Self::UpdateCommittee(update_committee)),
345 Err(e) => {
346 errs.push(e.annotate("UpdateCommittee"));
347 raw.as_mut_ref()
348 .seek(SeekFrom::Start(initial_position))
349 .unwrap();
350 }
351 };
352 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
353 let mut read_len = CBORReadLen::new(len);
354 read_len.read_elems(3)?;
355 read_len.finish()?;
356 let ret = NewConstitution::deserialize_as_embedded_group(raw, &mut read_len, len);
357 match len {
358 cbor_event::LenSz::Len(_, _) => (),
359 cbor_event::LenSz::Indefinite => match raw.special()? {
360 cbor_event::Special::Break => (),
361 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
362 },
363 }
364 ret
365 })(raw);
366 match deser_variant {
367 Ok(new_constitution) => return Ok(Self::NewConstitution(new_constitution)),
368 Err(e) => {
369 errs.push(e.annotate("NewConstitution"));
370 raw.as_mut_ref()
371 .seek(SeekFrom::Start(initial_position))
372 .unwrap();
373 }
374 };
375 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
376 let mut read_len = CBORReadLen::new(len);
377 read_len.read_elems(1)?;
378 read_len.finish()?;
379 let (info_action_value, info_action_encoding) = raw.unsigned_integer_sz()?;
380 if info_action_value != 6 {
381 return Err(DeserializeFailure::FixedValueMismatch {
382 found: Key::Uint(info_action_value),
383 expected: Key::Uint(6),
384 }
385 .into());
386 }
387 let ret = Ok(Some(info_action_encoding));
388 match len {
389 cbor_event::LenSz::Len(_, _) => (),
390 cbor_event::LenSz::Indefinite => match raw.special()? {
391 cbor_event::Special::Break => (),
392 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
393 },
394 }
395 ret
396 })(raw);
397 match deser_variant {
398 Ok(info_action_encoding) => {
399 return Ok(Self::InfoAction {
400 info_action_encoding,
401 len_encoding,
402 })
403 }
404 Err(e) => {
405 errs.push(e.annotate("InfoAction"));
406 raw.as_mut_ref()
407 .seek(SeekFrom::Start(initial_position))
408 .unwrap();
409 }
410 };
411 Err(DeserializeError::new(
412 "GovAction",
413 DeserializeFailure::NoVariantMatchedWithCauses(errs),
414 ))
415 })()
416 .map_err(|e| e.annotate("GovAction"))
417 }
418}
419
420impl Serialize for GovActionId {
421 fn serialize<'se, W: Write>(
422 &self,
423 serializer: &'se mut Serializer<W>,
424 force_canonical: bool,
425 ) -> cbor_event::Result<&'se mut Serializer<W>> {
426 serializer.write_array_sz(
427 self.encodings
428 .as_ref()
429 .map(|encs| encs.len_encoding)
430 .unwrap_or_default()
431 .to_len_sz(2, force_canonical),
432 )?;
433 serializer.write_bytes_sz(
434 self.transaction_id.to_raw_bytes(),
435 self.encodings
436 .as_ref()
437 .map(|encs| encs.transaction_id_encoding.clone())
438 .unwrap_or_default()
439 .to_str_len_sz(
440 self.transaction_id.to_raw_bytes().len() as u64,
441 force_canonical,
442 ),
443 )?;
444 serializer.write_unsigned_integer_sz(
445 self.gov_action_index,
446 fit_sz(
447 self.gov_action_index,
448 self.encodings
449 .as_ref()
450 .map(|encs| encs.gov_action_index_encoding)
451 .unwrap_or_default(),
452 force_canonical,
453 ),
454 )?;
455 self.encodings
456 .as_ref()
457 .map(|encs| encs.len_encoding)
458 .unwrap_or_default()
459 .end(serializer, force_canonical)
460 }
461}
462
463impl Deserialize for GovActionId {
464 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
465 let len = raw.array_sz()?;
466 let len_encoding: LenEncoding = len.into();
467 let mut read_len = CBORReadLen::new(len);
468 read_len.read_elems(2)?;
469 read_len.finish()?;
470 (|| -> Result<_, DeserializeError> {
471 let (transaction_id, transaction_id_encoding) = raw
472 .bytes_sz()
473 .map_err(Into::<DeserializeError>::into)
474 .and_then(|(bytes, enc)| {
475 TransactionHash::from_raw_bytes(&bytes)
476 .map(|bytes| (bytes, StringEncoding::from(enc)))
477 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
478 })
479 .map_err(|e: DeserializeError| e.annotate("transaction_id"))?;
480 let (gov_action_index, gov_action_index_encoding) = raw
481 .unsigned_integer_sz()
482 .map_err(Into::<DeserializeError>::into)
483 .map(|(x, enc)| (x, Some(enc)))
484 .map_err(|e: DeserializeError| e.annotate("gov_action_index"))?;
485 match len {
486 cbor_event::LenSz::Len(_, _) => (),
487 cbor_event::LenSz::Indefinite => match raw.special()? {
488 cbor_event::Special::Break => (),
489 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
490 },
491 }
492 Ok(GovActionId {
493 transaction_id,
494 gov_action_index,
495 encodings: Some(GovActionIdEncoding {
496 len_encoding,
497 transaction_id_encoding,
498 gov_action_index_encoding,
499 }),
500 })
501 })()
502 .map_err(|e| e.annotate("GovActionId"))
503 }
504}
505
506impl Serialize for HardForkInitiationAction {
507 fn serialize<'se, W: Write>(
508 &self,
509 serializer: &'se mut Serializer<W>,
510 force_canonical: bool,
511 ) -> cbor_event::Result<&'se mut Serializer<W>> {
512 serializer.write_array_sz(
513 self.encodings
514 .as_ref()
515 .map(|encs| encs.len_encoding)
516 .unwrap_or_default()
517 .to_len_sz(3, force_canonical),
518 )?;
519 self.serialize_as_embedded_group(serializer, force_canonical)
520 }
521}
522
523impl SerializeEmbeddedGroup for HardForkInitiationAction {
524 fn serialize_as_embedded_group<'se, W: Write>(
525 &self,
526 serializer: &'se mut Serializer<W>,
527 force_canonical: bool,
528 ) -> cbor_event::Result<&'se mut Serializer<W>> {
529 serializer.write_unsigned_integer_sz(
530 1u64,
531 fit_sz(
532 1u64,
533 self.encodings
534 .as_ref()
535 .map(|encs| encs.tag_encoding)
536 .unwrap_or_default(),
537 force_canonical,
538 ),
539 )?;
540 match &self.action_id {
541 Some(x) => x.serialize(serializer, force_canonical),
542 None => serializer.write_special(cbor_event::Special::Null),
543 }?;
544 self.version.serialize(serializer, force_canonical)?;
545 self.encodings
546 .as_ref()
547 .map(|encs| encs.len_encoding)
548 .unwrap_or_default()
549 .end(serializer, force_canonical)
550 }
551}
552
553impl Deserialize for HardForkInitiationAction {
554 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
555 let len = raw.array_sz()?;
556 let mut read_len = CBORReadLen::new(len);
557 read_len.read_elems(3)?;
558 read_len.finish()?;
559 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
560 match len {
561 cbor_event::LenSz::Len(_, _) => (),
562 cbor_event::LenSz::Indefinite => match raw.special()? {
563 cbor_event::Special::Break => (),
564 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
565 },
566 }
567 ret
568 }
569}
570
571impl DeserializeEmbeddedGroup for HardForkInitiationAction {
572 fn deserialize_as_embedded_group<R: BufRead + Seek>(
573 raw: &mut Deserializer<R>,
574 _read_len: &mut CBORReadLen,
575 len: cbor_event::LenSz,
576 ) -> Result<Self, DeserializeError> {
577 let len_encoding = len.into();
578 (|| -> Result<_, DeserializeError> {
579 let tag_encoding = (|| -> Result<_, DeserializeError> {
580 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
581 if tag_value != 1 {
582 return Err(DeserializeFailure::FixedValueMismatch {
583 found: Key::Uint(tag_value),
584 expected: Key::Uint(1),
585 }
586 .into());
587 }
588 Ok(Some(tag_encoding))
589 })()
590 .map_err(|e| e.annotate("tag"))?;
591 let action_id = (|| -> Result<_, DeserializeError> {
592 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
593 true => Some(GovActionId::deserialize(raw)?),
594 false => {
595 if raw.special()? != cbor_event::Special::Null {
596 return Err(DeserializeFailure::ExpectedNull.into());
597 }
598 None
599 }
600 })
601 })()
602 .map_err(|e| e.annotate("action_id"))?;
603 let version = ProtocolVersion::deserialize(raw)
604 .map_err(|e: DeserializeError| e.annotate("version"))?;
605 Ok(HardForkInitiationAction {
606 action_id,
607 version,
608 encodings: Some(HardForkInitiationActionEncoding {
609 len_encoding,
610 tag_encoding,
611 }),
612 })
613 })()
614 .map_err(|e| e.annotate("HardForkInitiationAction"))
615 }
616}
617
618impl Serialize for NewConstitution {
619 fn serialize<'se, W: Write>(
620 &self,
621 serializer: &'se mut Serializer<W>,
622 force_canonical: bool,
623 ) -> cbor_event::Result<&'se mut Serializer<W>> {
624 serializer.write_array_sz(
625 self.encodings
626 .as_ref()
627 .map(|encs| encs.len_encoding)
628 .unwrap_or_default()
629 .to_len_sz(3, force_canonical),
630 )?;
631 self.serialize_as_embedded_group(serializer, force_canonical)
632 }
633}
634
635impl SerializeEmbeddedGroup for NewConstitution {
636 fn serialize_as_embedded_group<'se, W: Write>(
637 &self,
638 serializer: &'se mut Serializer<W>,
639 force_canonical: bool,
640 ) -> cbor_event::Result<&'se mut Serializer<W>> {
641 serializer.write_unsigned_integer_sz(
642 5u64,
643 fit_sz(
644 5u64,
645 self.encodings
646 .as_ref()
647 .map(|encs| encs.tag_encoding)
648 .unwrap_or_default(),
649 force_canonical,
650 ),
651 )?;
652 match &self.action_id {
653 Some(x) => x.serialize(serializer, force_canonical),
654 None => serializer.write_special(cbor_event::Special::Null),
655 }?;
656 self.constitution.serialize(serializer, force_canonical)?;
657 self.encodings
658 .as_ref()
659 .map(|encs| encs.len_encoding)
660 .unwrap_or_default()
661 .end(serializer, force_canonical)
662 }
663}
664
665impl Deserialize for NewConstitution {
666 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
667 let len = raw.array_sz()?;
668 let mut read_len = CBORReadLen::new(len);
669 read_len.read_elems(3)?;
670 read_len.finish()?;
671 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
672 match len {
673 cbor_event::LenSz::Len(_, _) => (),
674 cbor_event::LenSz::Indefinite => match raw.special()? {
675 cbor_event::Special::Break => (),
676 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
677 },
678 }
679 ret
680 }
681}
682
683impl DeserializeEmbeddedGroup for NewConstitution {
684 fn deserialize_as_embedded_group<R: BufRead + Seek>(
685 raw: &mut Deserializer<R>,
686 _read_len: &mut CBORReadLen,
687 len: cbor_event::LenSz,
688 ) -> Result<Self, DeserializeError> {
689 let len_encoding = len.into();
690 (|| -> Result<_, DeserializeError> {
691 let tag_encoding = (|| -> Result<_, DeserializeError> {
692 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
693 if tag_value != 5 {
694 return Err(DeserializeFailure::FixedValueMismatch {
695 found: Key::Uint(tag_value),
696 expected: Key::Uint(5),
697 }
698 .into());
699 }
700 Ok(Some(tag_encoding))
701 })()
702 .map_err(|e| e.annotate("tag"))?;
703 let action_id = (|| -> Result<_, DeserializeError> {
704 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
705 true => Some(GovActionId::deserialize(raw)?),
706 false => {
707 if raw.special()? != cbor_event::Special::Null {
708 return Err(DeserializeFailure::ExpectedNull.into());
709 }
710 None
711 }
712 })
713 })()
714 .map_err(|e| e.annotate("action_id"))?;
715 let constitution = Constitution::deserialize(raw)
716 .map_err(|e: DeserializeError| e.annotate("constitution"))?;
717 Ok(NewConstitution {
718 action_id,
719 constitution,
720 encodings: Some(NewConstitutionEncoding {
721 len_encoding,
722 tag_encoding,
723 }),
724 })
725 })()
726 .map_err(|e| e.annotate("NewConstitution"))
727 }
728}
729
730impl Serialize for NoConfidence {
731 fn serialize<'se, W: Write>(
732 &self,
733 serializer: &'se mut Serializer<W>,
734 force_canonical: bool,
735 ) -> cbor_event::Result<&'se mut Serializer<W>> {
736 serializer.write_array_sz(
737 self.encodings
738 .as_ref()
739 .map(|encs| encs.len_encoding)
740 .unwrap_or_default()
741 .to_len_sz(2, force_canonical),
742 )?;
743 self.serialize_as_embedded_group(serializer, force_canonical)
744 }
745}
746
747impl SerializeEmbeddedGroup for NoConfidence {
748 fn serialize_as_embedded_group<'se, W: Write>(
749 &self,
750 serializer: &'se mut Serializer<W>,
751 force_canonical: bool,
752 ) -> cbor_event::Result<&'se mut Serializer<W>> {
753 serializer.write_unsigned_integer_sz(
754 3u64,
755 fit_sz(
756 3u64,
757 self.encodings
758 .as_ref()
759 .map(|encs| encs.tag_encoding)
760 .unwrap_or_default(),
761 force_canonical,
762 ),
763 )?;
764 match &self.action_id {
765 Some(x) => x.serialize(serializer, force_canonical),
766 None => serializer.write_special(cbor_event::Special::Null),
767 }?;
768 self.encodings
769 .as_ref()
770 .map(|encs| encs.len_encoding)
771 .unwrap_or_default()
772 .end(serializer, force_canonical)
773 }
774}
775
776impl Deserialize for NoConfidence {
777 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
778 let len = raw.array_sz()?;
779 let mut read_len = CBORReadLen::new(len);
780 read_len.read_elems(2)?;
781 read_len.finish()?;
782 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
783 match len {
784 cbor_event::LenSz::Len(_, _) => (),
785 cbor_event::LenSz::Indefinite => match raw.special()? {
786 cbor_event::Special::Break => (),
787 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
788 },
789 }
790 ret
791 }
792}
793
794impl DeserializeEmbeddedGroup for NoConfidence {
795 fn deserialize_as_embedded_group<R: BufRead + Seek>(
796 raw: &mut Deserializer<R>,
797 _read_len: &mut CBORReadLen,
798 len: cbor_event::LenSz,
799 ) -> Result<Self, DeserializeError> {
800 let len_encoding = len.into();
801 (|| -> Result<_, DeserializeError> {
802 let tag_encoding = (|| -> Result<_, DeserializeError> {
803 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
804 if tag_value != 3 {
805 return Err(DeserializeFailure::FixedValueMismatch {
806 found: Key::Uint(tag_value),
807 expected: Key::Uint(3),
808 }
809 .into());
810 }
811 Ok(Some(tag_encoding))
812 })()
813 .map_err(|e| e.annotate("tag"))?;
814 let action_id = (|| -> Result<_, DeserializeError> {
815 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
816 true => Some(GovActionId::deserialize(raw)?),
817 false => {
818 if raw.special()? != cbor_event::Special::Null {
819 return Err(DeserializeFailure::ExpectedNull.into());
820 }
821 None
822 }
823 })
824 })()
825 .map_err(|e| e.annotate("action_id"))?;
826 Ok(NoConfidence {
827 action_id,
828 encodings: Some(NoConfidenceEncoding {
829 len_encoding,
830 tag_encoding,
831 }),
832 })
833 })()
834 .map_err(|e| e.annotate("NoConfidence"))
835 }
836}
837
838impl Serialize for ParameterChangeAction {
839 fn serialize<'se, W: Write>(
840 &self,
841 serializer: &'se mut Serializer<W>,
842 force_canonical: bool,
843 ) -> cbor_event::Result<&'se mut Serializer<W>> {
844 serializer.write_array_sz(
845 self.encodings
846 .as_ref()
847 .map(|encs| encs.len_encoding)
848 .unwrap_or_default()
849 .to_len_sz(4, force_canonical),
850 )?;
851 self.serialize_as_embedded_group(serializer, force_canonical)
852 }
853}
854
855impl SerializeEmbeddedGroup for ParameterChangeAction {
856 fn serialize_as_embedded_group<'se, W: Write>(
857 &self,
858 serializer: &'se mut Serializer<W>,
859 force_canonical: bool,
860 ) -> cbor_event::Result<&'se mut Serializer<W>> {
861 serializer.write_unsigned_integer_sz(
862 0u64,
863 fit_sz(
864 0u64,
865 self.encodings
866 .as_ref()
867 .map(|encs| encs.tag_encoding)
868 .unwrap_or_default(),
869 force_canonical,
870 ),
871 )?;
872 match &self.action_id {
873 Some(x) => x.serialize(serializer, force_canonical),
874 None => serializer.write_special(cbor_event::Special::Null),
875 }?;
876 self.update.serialize(serializer, force_canonical)?;
877 match &self.policy_hash {
878 Some(x) => serializer.write_bytes_sz(
879 x.to_raw_bytes(),
880 self.encodings
881 .as_ref()
882 .map(|encs| encs.policy_hash_encoding.clone())
883 .unwrap_or_default()
884 .to_str_len_sz(x.to_raw_bytes().len() as u64, force_canonical),
885 ),
886 None => serializer.write_special(cbor_event::Special::Null),
887 }?;
888 self.encodings
889 .as_ref()
890 .map(|encs| encs.len_encoding)
891 .unwrap_or_default()
892 .end(serializer, force_canonical)
893 }
894}
895
896impl Deserialize for ParameterChangeAction {
897 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
898 let len = raw.array_sz()?;
899 let mut read_len = CBORReadLen::new(len);
900 read_len.read_elems(4)?;
901 read_len.finish()?;
902 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
903 match len {
904 cbor_event::LenSz::Len(_, _) => (),
905 cbor_event::LenSz::Indefinite => match raw.special()? {
906 cbor_event::Special::Break => (),
907 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
908 },
909 }
910 ret
911 }
912}
913
914impl DeserializeEmbeddedGroup for ParameterChangeAction {
915 fn deserialize_as_embedded_group<R: BufRead + Seek>(
916 raw: &mut Deserializer<R>,
917 _read_len: &mut CBORReadLen,
918 len: cbor_event::LenSz,
919 ) -> Result<Self, DeserializeError> {
920 let len_encoding = len.into();
921 (|| -> Result<_, DeserializeError> {
922 let tag_encoding = (|| -> Result<_, DeserializeError> {
923 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
924 if tag_value != 0 {
925 return Err(DeserializeFailure::FixedValueMismatch {
926 found: Key::Uint(tag_value),
927 expected: Key::Uint(0),
928 }
929 .into());
930 }
931 Ok(Some(tag_encoding))
932 })()
933 .map_err(|e| e.annotate("tag"))?;
934 let action_id = (|| -> Result<_, DeserializeError> {
935 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
936 true => Some(GovActionId::deserialize(raw)?),
937 false => {
938 if raw.special()? != cbor_event::Special::Null {
939 return Err(DeserializeFailure::ExpectedNull.into());
940 }
941 None
942 }
943 })
944 })()
945 .map_err(|e| e.annotate("action_id"))?;
946 let update = ProtocolParamUpdate::deserialize(raw)
947 .map_err(|e: DeserializeError| e.annotate("update"))?;
948 let (policy_hash, policy_hash_encoding) = (|| -> Result<_, DeserializeError> {
949 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
950 true => Result::<_, DeserializeError>::Ok(
951 raw.bytes_sz()
952 .map_err(Into::<DeserializeError>::into)
953 .and_then(|(bytes, enc)| {
954 ScriptHash::from_raw_bytes(&bytes)
955 .map(|bytes| (bytes, StringEncoding::from(enc)))
956 .map_err(|e| {
957 DeserializeFailure::InvalidStructure(Box::new(e)).into()
958 })
959 })?,
960 )
961 .map(|(x, policy_hash_encoding)| (Some(x), policy_hash_encoding))?,
962 false => {
963 if raw.special()? != cbor_event::Special::Null {
964 return Err(DeserializeFailure::ExpectedNull.into());
965 }
966 (None, StringEncoding::default())
967 }
968 })
969 })()
970 .map_err(|e| e.annotate("policy_hash"))?;
971 Ok(ParameterChangeAction {
972 action_id,
973 update,
974 policy_hash,
975 encodings: Some(ParameterChangeActionEncoding {
976 len_encoding,
977 tag_encoding,
978 policy_hash_encoding,
979 }),
980 })
981 })()
982 .map_err(|e| e.annotate("ParameterChangeAction"))
983 }
984}
985
986impl Serialize for ProposalProcedure {
987 fn serialize<'se, W: Write>(
988 &self,
989 serializer: &'se mut Serializer<W>,
990 force_canonical: bool,
991 ) -> cbor_event::Result<&'se mut Serializer<W>> {
992 serializer.write_array_sz(
993 self.encodings
994 .as_ref()
995 .map(|encs| encs.len_encoding)
996 .unwrap_or_default()
997 .to_len_sz(4, force_canonical),
998 )?;
999 serializer.write_unsigned_integer_sz(
1000 self.deposit,
1001 fit_sz(
1002 self.deposit,
1003 self.encodings
1004 .as_ref()
1005 .map(|encs| encs.deposit_encoding)
1006 .unwrap_or_default(),
1007 force_canonical,
1008 ),
1009 )?;
1010 self.reward_account.serialize(serializer, force_canonical)?;
1011 self.gov_action.serialize(serializer, force_canonical)?;
1012 self.anchor.serialize(serializer, force_canonical)?;
1013 self.encodings
1014 .as_ref()
1015 .map(|encs| encs.len_encoding)
1016 .unwrap_or_default()
1017 .end(serializer, force_canonical)
1018 }
1019}
1020
1021impl Deserialize for ProposalProcedure {
1022 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1023 let len = raw.array_sz()?;
1024 let len_encoding: LenEncoding = len.into();
1025 let mut read_len = CBORReadLen::new(len);
1026 read_len.read_elems(4)?;
1027 read_len.finish()?;
1028 (|| -> Result<_, DeserializeError> {
1029 let (deposit, deposit_encoding) = raw
1030 .unsigned_integer_sz()
1031 .map_err(Into::<DeserializeError>::into)
1032 .map(|(x, enc)| (x, Some(enc)))
1033 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
1034 let reward_account = RewardAccount::deserialize(raw)
1035 .map_err(|e: DeserializeError| e.annotate("reward_account"))?;
1036 let gov_action = GovAction::deserialize(raw)
1037 .map_err(|e: DeserializeError| e.annotate("gov_action"))?;
1038 let anchor =
1039 Anchor::deserialize(raw).map_err(|e: DeserializeError| e.annotate("anchor"))?;
1040 match len {
1041 cbor_event::LenSz::Len(_, _) => (),
1042 cbor_event::LenSz::Indefinite => match raw.special()? {
1043 cbor_event::Special::Break => (),
1044 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1045 },
1046 }
1047 Ok(ProposalProcedure {
1048 deposit,
1049 reward_account,
1050 gov_action,
1051 anchor,
1052 encodings: Some(ProposalProcedureEncoding {
1053 len_encoding,
1054 deposit_encoding,
1055 }),
1056 })
1057 })()
1058 .map_err(|e| e.annotate("ProposalProcedure"))
1059 }
1060}
1061
1062impl Serialize for TreasuryWithdrawalsAction {
1063 fn serialize<'se, W: Write>(
1064 &self,
1065 serializer: &'se mut Serializer<W>,
1066 force_canonical: bool,
1067 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1068 serializer.write_array_sz(
1069 self.encodings
1070 .as_ref()
1071 .map(|encs| encs.len_encoding)
1072 .unwrap_or_default()
1073 .to_len_sz(3, force_canonical),
1074 )?;
1075 self.serialize_as_embedded_group(serializer, force_canonical)
1076 }
1077}
1078
1079impl SerializeEmbeddedGroup for TreasuryWithdrawalsAction {
1080 fn serialize_as_embedded_group<'se, W: Write>(
1081 &self,
1082 serializer: &'se mut Serializer<W>,
1083 force_canonical: bool,
1084 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1085 serializer.write_unsigned_integer_sz(
1086 2u64,
1087 fit_sz(
1088 2u64,
1089 self.encodings
1090 .as_ref()
1091 .map(|encs| encs.tag_encoding)
1092 .unwrap_or_default(),
1093 force_canonical,
1094 ),
1095 )?;
1096 serializer.write_map_sz(
1097 self.encodings
1098 .as_ref()
1099 .map(|encs| encs.withdrawal_encoding)
1100 .unwrap_or_default()
1101 .to_len_sz(self.withdrawal.len() as u64, force_canonical),
1102 )?;
1103 let mut key_order = self
1104 .withdrawal
1105 .iter()
1106 .map(|(k, v)| {
1107 let mut buf = cbor_event::se::Serializer::new_vec();
1108 k.serialize(&mut buf, force_canonical)?;
1109 Ok((buf.finalize(), k, v))
1110 })
1111 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
1112 if force_canonical {
1113 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
1114 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
1115 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
1116 diff_ord => diff_ord,
1117 }
1118 });
1119 }
1120 for (key_bytes, key, value) in key_order {
1121 serializer.write_raw_bytes(&key_bytes)?;
1122 let withdrawal_value_encoding = self
1123 .encodings
1124 .as_ref()
1125 .and_then(|encs| encs.withdrawal_value_encodings.get(key))
1126 .cloned()
1127 .unwrap_or_default();
1128 serializer.write_unsigned_integer_sz(
1129 *value,
1130 fit_sz(*value, withdrawal_value_encoding, force_canonical),
1131 )?;
1132 }
1133 self.encodings
1134 .as_ref()
1135 .map(|encs| encs.withdrawal_encoding)
1136 .unwrap_or_default()
1137 .end(serializer, force_canonical)?;
1138 match &self.policy_hash {
1139 Some(x) => serializer.write_bytes_sz(
1140 x.to_raw_bytes(),
1141 self.encodings
1142 .as_ref()
1143 .map(|encs| encs.policy_hash_encoding.clone())
1144 .unwrap_or_default()
1145 .to_str_len_sz(x.to_raw_bytes().len() as u64, force_canonical),
1146 ),
1147 None => serializer.write_special(cbor_event::Special::Null),
1148 }?;
1149 self.encodings
1150 .as_ref()
1151 .map(|encs| encs.len_encoding)
1152 .unwrap_or_default()
1153 .end(serializer, force_canonical)
1154 }
1155}
1156
1157impl Deserialize for TreasuryWithdrawalsAction {
1158 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1159 let len = raw.array_sz()?;
1160 let mut read_len = CBORReadLen::new(len);
1161 read_len.read_elems(3)?;
1162 read_len.finish()?;
1163 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1164 match len {
1165 cbor_event::LenSz::Len(_, _) => (),
1166 cbor_event::LenSz::Indefinite => match raw.special()? {
1167 cbor_event::Special::Break => (),
1168 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1169 },
1170 }
1171 ret
1172 }
1173}
1174
1175impl DeserializeEmbeddedGroup for TreasuryWithdrawalsAction {
1176 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1177 raw: &mut Deserializer<R>,
1178 _read_len: &mut CBORReadLen,
1179 len: cbor_event::LenSz,
1180 ) -> Result<Self, DeserializeError> {
1181 let len_encoding = len.into();
1182 (|| -> Result<_, DeserializeError> {
1183 let tag_encoding = (|| -> Result<_, DeserializeError> {
1184 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1185 if tag_value != 2 {
1186 return Err(DeserializeFailure::FixedValueMismatch {
1187 found: Key::Uint(tag_value),
1188 expected: Key::Uint(2),
1189 }
1190 .into());
1191 }
1192 Ok(Some(tag_encoding))
1193 })()
1194 .map_err(|e| e.annotate("tag"))?;
1195 let (withdrawal, withdrawal_encoding, withdrawal_value_encodings) =
1196 (|| -> Result<_, DeserializeError> {
1197 let mut withdrawal_table = OrderedHashMap::new();
1198 let withdrawal_len = raw.map_sz()?;
1199 let withdrawal_encoding = withdrawal_len.into();
1200 let mut withdrawal_value_encodings = BTreeMap::new();
1201 while match withdrawal_len {
1202 cbor_event::LenSz::Len(n, _) => (withdrawal_table.len() as u64) < n,
1203 cbor_event::LenSz::Indefinite => true,
1204 } {
1205 if raw.cbor_type()? == cbor_event::Type::Special {
1206 assert_eq!(raw.special()?, cbor_event::Special::Break);
1207 break;
1208 }
1209 let withdrawal_key = RewardAccount::deserialize(raw)?;
1210 let (withdrawal_value, withdrawal_value_encoding) =
1211 raw.unsigned_integer_sz().map(|(x, enc)| (x, Some(enc)))?;
1212 if withdrawal_table
1213 .insert(withdrawal_key.clone(), withdrawal_value)
1214 .is_some()
1215 {
1216 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1217 "some complicated/unsupported type",
1218 )))
1219 .into());
1220 }
1221 withdrawal_value_encodings
1222 .insert(withdrawal_key, withdrawal_value_encoding);
1223 }
1224 Ok((
1225 withdrawal_table,
1226 withdrawal_encoding,
1227 withdrawal_value_encodings,
1228 ))
1229 })()
1230 .map_err(|e| e.annotate("withdrawal"))?;
1231 let (policy_hash, policy_hash_encoding) = (|| -> Result<_, DeserializeError> {
1232 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
1233 true => Result::<_, DeserializeError>::Ok(
1234 raw.bytes_sz()
1235 .map_err(Into::<DeserializeError>::into)
1236 .and_then(|(bytes, enc)| {
1237 ScriptHash::from_raw_bytes(&bytes)
1238 .map(|bytes| (bytes, StringEncoding::from(enc)))
1239 .map_err(|e| {
1240 DeserializeFailure::InvalidStructure(Box::new(e)).into()
1241 })
1242 })?,
1243 )
1244 .map(|(x, policy_hash_encoding)| (Some(x), policy_hash_encoding))?,
1245 false => {
1246 if raw.special()? != cbor_event::Special::Null {
1247 return Err(DeserializeFailure::ExpectedNull.into());
1248 }
1249 (None, StringEncoding::default())
1250 }
1251 })
1252 })()
1253 .map_err(|e| e.annotate("policy_hash"))?;
1254 Ok(TreasuryWithdrawalsAction {
1255 withdrawal,
1256 policy_hash,
1257 encodings: Some(TreasuryWithdrawalsActionEncoding {
1258 len_encoding,
1259 tag_encoding,
1260 withdrawal_encoding,
1261 withdrawal_value_encodings,
1262 policy_hash_encoding,
1263 }),
1264 })
1265 })()
1266 .map_err(|e| e.annotate("TreasuryWithdrawalsAction"))
1267 }
1268}
1269
1270impl Serialize for UpdateCommittee {
1271 fn serialize<'se, W: Write>(
1272 &self,
1273 serializer: &'se mut Serializer<W>,
1274 force_canonical: bool,
1275 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1276 serializer.write_array_sz(
1277 self.encodings
1278 .as_ref()
1279 .map(|encs| encs.len_encoding)
1280 .unwrap_or_default()
1281 .to_len_sz(5, force_canonical),
1282 )?;
1283 self.serialize_as_embedded_group(serializer, force_canonical)
1284 }
1285}
1286
1287impl SerializeEmbeddedGroup for UpdateCommittee {
1288 fn serialize_as_embedded_group<'se, W: Write>(
1289 &self,
1290 serializer: &'se mut Serializer<W>,
1291 force_canonical: bool,
1292 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1293 serializer.write_unsigned_integer_sz(
1294 4u64,
1295 fit_sz(
1296 4u64,
1297 self.encodings
1298 .as_ref()
1299 .map(|encs| encs.tag_encoding)
1300 .unwrap_or_default(),
1301 force_canonical,
1302 ),
1303 )?;
1304 match &self.action_id {
1305 Some(x) => x.serialize(serializer, force_canonical),
1306 None => serializer.write_special(cbor_event::Special::Null),
1307 }?;
1308 self.cold_credentials
1309 .serialize(serializer, force_canonical)?;
1310 serializer.write_map_sz(
1311 self.encodings
1312 .as_ref()
1313 .map(|encs| encs.credentials_encoding)
1314 .unwrap_or_default()
1315 .to_len_sz(self.credentials.len() as u64, force_canonical),
1316 )?;
1317 let mut key_order = self
1318 .credentials
1319 .iter()
1320 .map(|(k, v)| {
1321 let mut buf = cbor_event::se::Serializer::new_vec();
1322 k.serialize(&mut buf, force_canonical)?;
1323 Ok((buf.finalize(), k, v))
1324 })
1325 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
1326 if force_canonical {
1327 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
1328 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
1329 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
1330 diff_ord => diff_ord,
1331 }
1332 });
1333 }
1334 for (key_bytes, key, value) in key_order {
1335 serializer.write_raw_bytes(&key_bytes)?;
1336 let credentials_value_encoding = self
1337 .encodings
1338 .as_ref()
1339 .and_then(|encs| encs.credentials_value_encodings.get(key))
1340 .cloned()
1341 .unwrap_or_default();
1342 serializer.write_unsigned_integer_sz(
1343 *value,
1344 fit_sz(*value, credentials_value_encoding, force_canonical),
1345 )?;
1346 }
1347 self.encodings
1348 .as_ref()
1349 .map(|encs| encs.credentials_encoding)
1350 .unwrap_or_default()
1351 .end(serializer, force_canonical)?;
1352 self.unit_interval.serialize(serializer, force_canonical)?;
1353 self.encodings
1354 .as_ref()
1355 .map(|encs| encs.len_encoding)
1356 .unwrap_or_default()
1357 .end(serializer, force_canonical)
1358 }
1359}
1360
1361impl Deserialize for UpdateCommittee {
1362 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1363 let len = raw.array_sz()?;
1364 let mut read_len = CBORReadLen::new(len);
1365 read_len.read_elems(5)?;
1366 read_len.finish()?;
1367 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1368 match len {
1369 cbor_event::LenSz::Len(_, _) => (),
1370 cbor_event::LenSz::Indefinite => match raw.special()? {
1371 cbor_event::Special::Break => (),
1372 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1373 },
1374 }
1375 ret
1376 }
1377}
1378
1379impl DeserializeEmbeddedGroup for UpdateCommittee {
1380 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1381 raw: &mut Deserializer<R>,
1382 _read_len: &mut CBORReadLen,
1383 len: cbor_event::LenSz,
1384 ) -> Result<Self, DeserializeError> {
1385 let len_encoding = len.into();
1386 (|| -> Result<_, DeserializeError> {
1387 let tag_encoding = (|| -> Result<_, DeserializeError> {
1388 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1389 if tag_value != 4 {
1390 return Err(DeserializeFailure::FixedValueMismatch {
1391 found: Key::Uint(tag_value),
1392 expected: Key::Uint(4),
1393 }
1394 .into());
1395 }
1396 Ok(Some(tag_encoding))
1397 })()
1398 .map_err(|e| e.annotate("tag"))?;
1399 let action_id = (|| -> Result<_, DeserializeError> {
1400 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
1401 true => Some(GovActionId::deserialize(raw)?),
1402 false => {
1403 if raw.special()? != cbor_event::Special::Null {
1404 return Err(DeserializeFailure::ExpectedNull.into());
1405 }
1406 None
1407 }
1408 })
1409 })()
1410 .map_err(|e| e.annotate("action_id"))?;
1411 let cold_credentials = SetCommitteeColdCredential::deserialize(raw)
1412 .map_err(|e: DeserializeError| e.annotate("cold_credentials"))?;
1413 let (credentials, credentials_encoding, credentials_value_encodings) =
1414 (|| -> Result<_, DeserializeError> {
1415 let mut credentials_table = OrderedHashMap::new();
1416 let credentials_len = raw.map_sz()?;
1417 let credentials_encoding = credentials_len.into();
1418 let mut credentials_value_encodings = BTreeMap::new();
1419 while match credentials_len {
1420 cbor_event::LenSz::Len(n, _) => (credentials_table.len() as u64) < n,
1421 cbor_event::LenSz::Indefinite => true,
1422 } {
1423 if raw.cbor_type()? == cbor_event::Type::Special {
1424 assert_eq!(raw.special()?, cbor_event::Special::Break);
1425 break;
1426 }
1427 let credentials_key = Credential::deserialize(raw)?;
1428 let (credentials_value, credentials_value_encoding) =
1429 raw.unsigned_integer_sz().map(|(x, enc)| (x, Some(enc)))?;
1430 if credentials_table
1431 .insert(credentials_key.clone(), credentials_value)
1432 .is_some()
1433 {
1434 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1435 "some complicated/unsupported type",
1436 )))
1437 .into());
1438 }
1439 credentials_value_encodings
1440 .insert(credentials_key, credentials_value_encoding);
1441 }
1442 Ok((
1443 credentials_table,
1444 credentials_encoding,
1445 credentials_value_encodings,
1446 ))
1447 })()
1448 .map_err(|e| e.annotate("credentials"))?;
1449 let unit_interval = UnitInterval::deserialize(raw)
1450 .map_err(|e: DeserializeError| e.annotate("unit_interval"))?;
1451 Ok(UpdateCommittee {
1452 action_id,
1453 cold_credentials,
1454 credentials,
1455 unit_interval,
1456 encodings: Some(UpdateCommitteeEncoding {
1457 len_encoding,
1458 tag_encoding,
1459 credentials_encoding,
1460 credentials_value_encodings,
1461 }),
1462 })
1463 })()
1464 .map_err(|e| e.annotate("UpdateCommittee"))
1465 }
1466}
1467
1468impl Serialize for Voter {
1469 fn serialize<'se, W: Write>(
1470 &self,
1471 serializer: &'se mut Serializer<W>,
1472 force_canonical: bool,
1473 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1474 match self {
1475 Voter::ConstitutionalCommitteeHotKeyHash {
1476 ed25519_key_hash,
1477 len_encoding,
1478 index_0_encoding,
1479 ed25519_key_hash_encoding,
1480 } => {
1481 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
1482 serializer.write_unsigned_integer_sz(
1483 0u64,
1484 fit_sz(0u64, *index_0_encoding, force_canonical),
1485 )?;
1486 serializer.write_bytes_sz(
1487 ed25519_key_hash.to_raw_bytes(),
1488 ed25519_key_hash_encoding.to_str_len_sz(
1489 ed25519_key_hash.to_raw_bytes().len() as u64,
1490 force_canonical,
1491 ),
1492 )?;
1493 len_encoding.end(serializer, force_canonical)?;
1494 Ok(serializer)
1495 }
1496 Voter::ConstitutionalCommitteeHotScriptHash {
1497 script_hash,
1498 len_encoding,
1499 index_0_encoding,
1500 script_hash_encoding,
1501 } => {
1502 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
1503 serializer.write_unsigned_integer_sz(
1504 1u64,
1505 fit_sz(1u64, *index_0_encoding, force_canonical),
1506 )?;
1507 serializer.write_bytes_sz(
1508 script_hash.to_raw_bytes(),
1509 script_hash_encoding
1510 .to_str_len_sz(script_hash.to_raw_bytes().len() as u64, force_canonical),
1511 )?;
1512 len_encoding.end(serializer, force_canonical)?;
1513 Ok(serializer)
1514 }
1515 Voter::DRepKeyHash {
1516 ed25519_key_hash,
1517 len_encoding,
1518 index_0_encoding,
1519 ed25519_key_hash_encoding,
1520 } => {
1521 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
1522 serializer.write_unsigned_integer_sz(
1523 2u64,
1524 fit_sz(2u64, *index_0_encoding, force_canonical),
1525 )?;
1526 serializer.write_bytes_sz(
1527 ed25519_key_hash.to_raw_bytes(),
1528 ed25519_key_hash_encoding.to_str_len_sz(
1529 ed25519_key_hash.to_raw_bytes().len() as u64,
1530 force_canonical,
1531 ),
1532 )?;
1533 len_encoding.end(serializer, force_canonical)?;
1534 Ok(serializer)
1535 }
1536 Voter::DRepScriptHash {
1537 script_hash,
1538 len_encoding,
1539 index_0_encoding,
1540 script_hash_encoding,
1541 } => {
1542 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
1543 serializer.write_unsigned_integer_sz(
1544 3u64,
1545 fit_sz(3u64, *index_0_encoding, force_canonical),
1546 )?;
1547 serializer.write_bytes_sz(
1548 script_hash.to_raw_bytes(),
1549 script_hash_encoding
1550 .to_str_len_sz(script_hash.to_raw_bytes().len() as u64, force_canonical),
1551 )?;
1552 len_encoding.end(serializer, force_canonical)?;
1553 Ok(serializer)
1554 }
1555 Voter::StakingPoolKeyHash {
1556 ed25519_key_hash,
1557 len_encoding,
1558 index_0_encoding,
1559 ed25519_key_hash_encoding,
1560 } => {
1561 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
1562 serializer.write_unsigned_integer_sz(
1563 4u64,
1564 fit_sz(4u64, *index_0_encoding, force_canonical),
1565 )?;
1566 serializer.write_bytes_sz(
1567 ed25519_key_hash.to_raw_bytes(),
1568 ed25519_key_hash_encoding.to_str_len_sz(
1569 ed25519_key_hash.to_raw_bytes().len() as u64,
1570 force_canonical,
1571 ),
1572 )?;
1573 len_encoding.end(serializer, force_canonical)?;
1574 Ok(serializer)
1575 }
1576 }
1577 }
1578}
1579
1580impl Deserialize for Voter {
1581 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1582 (|| -> Result<_, DeserializeError> {
1583 let len = raw.array_sz()?;
1584 let len_encoding: LenEncoding = len.into();
1585 let initial_position = raw.as_mut_ref().stream_position().unwrap();
1586 let mut errs = Vec::new();
1587 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1588 let mut read_len = CBORReadLen::new(len);
1589 read_len.read_elems(2)?;
1590 read_len.finish()?;
1591 let index_0_encoding = (|| -> Result<_, DeserializeError> {
1592 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
1593 if index_0_value != 0 {
1594 return Err(DeserializeFailure::FixedValueMismatch {
1595 found: Key::Uint(index_0_value),
1596 expected: Key::Uint(0),
1597 }
1598 .into());
1599 }
1600 Ok(Some(index_0_encoding))
1601 })()
1602 .map_err(|e| e.annotate("index_0"))?;
1603 let (ed25519_key_hash, ed25519_key_hash_encoding) = raw
1604 .bytes_sz()
1605 .map_err(Into::<DeserializeError>::into)
1606 .and_then(|(bytes, enc)| {
1607 Ed25519KeyHash::from_raw_bytes(&bytes)
1608 .map(|bytes| (bytes, StringEncoding::from(enc)))
1609 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1610 })
1611 .map_err(|e: DeserializeError| e.annotate("ed25519_key_hash"))?;
1612 match len {
1613 cbor_event::LenSz::Len(_, _) => (),
1614 cbor_event::LenSz::Indefinite => match raw.special()? {
1615 cbor_event::Special::Break => (),
1616 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1617 },
1618 }
1619 Ok(Self::ConstitutionalCommitteeHotKeyHash {
1620 ed25519_key_hash,
1621 len_encoding,
1622 index_0_encoding,
1623 ed25519_key_hash_encoding,
1624 })
1625 })(raw);
1626 match variant_deser {
1627 Ok(variant) => return Ok(variant),
1628 Err(e) => {
1629 errs.push(e.annotate("ConstitutionalCommitteeHotKeyHash"));
1630 raw.as_mut_ref()
1631 .seek(SeekFrom::Start(initial_position))
1632 .unwrap();
1633 }
1634 };
1635 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1636 let mut read_len = CBORReadLen::new(len);
1637 read_len.read_elems(2)?;
1638 read_len.finish()?;
1639 let index_0_encoding = (|| -> Result<_, DeserializeError> {
1640 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
1641 if index_0_value != 1 {
1642 return Err(DeserializeFailure::FixedValueMismatch {
1643 found: Key::Uint(index_0_value),
1644 expected: Key::Uint(1),
1645 }
1646 .into());
1647 }
1648 Ok(Some(index_0_encoding))
1649 })()
1650 .map_err(|e| e.annotate("index_0"))?;
1651 let (script_hash, script_hash_encoding) = raw
1652 .bytes_sz()
1653 .map_err(Into::<DeserializeError>::into)
1654 .and_then(|(bytes, enc)| {
1655 ScriptHash::from_raw_bytes(&bytes)
1656 .map(|bytes| (bytes, StringEncoding::from(enc)))
1657 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1658 })
1659 .map_err(|e: DeserializeError| e.annotate("script_hash"))?;
1660 match len {
1661 cbor_event::LenSz::Len(_, _) => (),
1662 cbor_event::LenSz::Indefinite => match raw.special()? {
1663 cbor_event::Special::Break => (),
1664 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1665 },
1666 }
1667 Ok(Self::ConstitutionalCommitteeHotScriptHash {
1668 script_hash,
1669 len_encoding,
1670 index_0_encoding,
1671 script_hash_encoding,
1672 })
1673 })(raw);
1674 match variant_deser {
1675 Ok(variant) => return Ok(variant),
1676 Err(e) => {
1677 errs.push(e.annotate("ConstitutionalCommitteeHotScriptHash"));
1678 raw.as_mut_ref()
1679 .seek(SeekFrom::Start(initial_position))
1680 .unwrap();
1681 }
1682 };
1683 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1684 let mut read_len = CBORReadLen::new(len);
1685 read_len.read_elems(2)?;
1686 read_len.finish()?;
1687 let index_0_encoding = (|| -> Result<_, DeserializeError> {
1688 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
1689 if index_0_value != 2 {
1690 return Err(DeserializeFailure::FixedValueMismatch {
1691 found: Key::Uint(index_0_value),
1692 expected: Key::Uint(2),
1693 }
1694 .into());
1695 }
1696 Ok(Some(index_0_encoding))
1697 })()
1698 .map_err(|e| e.annotate("index_0"))?;
1699 let (ed25519_key_hash, ed25519_key_hash_encoding) = raw
1700 .bytes_sz()
1701 .map_err(Into::<DeserializeError>::into)
1702 .and_then(|(bytes, enc)| {
1703 Ed25519KeyHash::from_raw_bytes(&bytes)
1704 .map(|bytes| (bytes, StringEncoding::from(enc)))
1705 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1706 })
1707 .map_err(|e: DeserializeError| e.annotate("ed25519_key_hash"))?;
1708 match len {
1709 cbor_event::LenSz::Len(_, _) => (),
1710 cbor_event::LenSz::Indefinite => match raw.special()? {
1711 cbor_event::Special::Break => (),
1712 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1713 },
1714 }
1715 Ok(Self::DRepKeyHash {
1716 ed25519_key_hash,
1717 len_encoding,
1718 index_0_encoding,
1719 ed25519_key_hash_encoding,
1720 })
1721 })(raw);
1722 match variant_deser {
1723 Ok(variant) => return Ok(variant),
1724 Err(e) => {
1725 errs.push(e.annotate("DRepKeyHash"));
1726 raw.as_mut_ref()
1727 .seek(SeekFrom::Start(initial_position))
1728 .unwrap();
1729 }
1730 };
1731 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1732 let mut read_len = CBORReadLen::new(len);
1733 read_len.read_elems(2)?;
1734 read_len.finish()?;
1735 let index_0_encoding = (|| -> Result<_, DeserializeError> {
1736 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
1737 if index_0_value != 3 {
1738 return Err(DeserializeFailure::FixedValueMismatch {
1739 found: Key::Uint(index_0_value),
1740 expected: Key::Uint(3),
1741 }
1742 .into());
1743 }
1744 Ok(Some(index_0_encoding))
1745 })()
1746 .map_err(|e| e.annotate("index_0"))?;
1747 let (script_hash, script_hash_encoding) = raw
1748 .bytes_sz()
1749 .map_err(Into::<DeserializeError>::into)
1750 .and_then(|(bytes, enc)| {
1751 ScriptHash::from_raw_bytes(&bytes)
1752 .map(|bytes| (bytes, StringEncoding::from(enc)))
1753 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1754 })
1755 .map_err(|e: DeserializeError| e.annotate("script_hash"))?;
1756 match len {
1757 cbor_event::LenSz::Len(_, _) => (),
1758 cbor_event::LenSz::Indefinite => match raw.special()? {
1759 cbor_event::Special::Break => (),
1760 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1761 },
1762 }
1763 Ok(Self::DRepScriptHash {
1764 script_hash,
1765 len_encoding,
1766 index_0_encoding,
1767 script_hash_encoding,
1768 })
1769 })(raw);
1770 match variant_deser {
1771 Ok(variant) => return Ok(variant),
1772 Err(e) => {
1773 errs.push(e.annotate("DRepScriptHash"));
1774 raw.as_mut_ref()
1775 .seek(SeekFrom::Start(initial_position))
1776 .unwrap();
1777 }
1778 };
1779 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1780 let mut read_len = CBORReadLen::new(len);
1781 read_len.read_elems(2)?;
1782 read_len.finish()?;
1783 let index_0_encoding = (|| -> Result<_, DeserializeError> {
1784 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
1785 if index_0_value != 4 {
1786 return Err(DeserializeFailure::FixedValueMismatch {
1787 found: Key::Uint(index_0_value),
1788 expected: Key::Uint(4),
1789 }
1790 .into());
1791 }
1792 Ok(Some(index_0_encoding))
1793 })()
1794 .map_err(|e| e.annotate("index_0"))?;
1795 let (ed25519_key_hash, ed25519_key_hash_encoding) = raw
1796 .bytes_sz()
1797 .map_err(Into::<DeserializeError>::into)
1798 .and_then(|(bytes, enc)| {
1799 Ed25519KeyHash::from_raw_bytes(&bytes)
1800 .map(|bytes| (bytes, StringEncoding::from(enc)))
1801 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1802 })
1803 .map_err(|e: DeserializeError| e.annotate("ed25519_key_hash"))?;
1804 match len {
1805 cbor_event::LenSz::Len(_, _) => (),
1806 cbor_event::LenSz::Indefinite => match raw.special()? {
1807 cbor_event::Special::Break => (),
1808 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1809 },
1810 }
1811 Ok(Self::StakingPoolKeyHash {
1812 ed25519_key_hash,
1813 len_encoding,
1814 index_0_encoding,
1815 ed25519_key_hash_encoding,
1816 })
1817 })(raw);
1818 match variant_deser {
1819 Ok(variant) => return Ok(variant),
1820 Err(e) => {
1821 errs.push(e.annotate("StakingPoolKeyHash"));
1822 raw.as_mut_ref()
1823 .seek(SeekFrom::Start(initial_position))
1824 .unwrap();
1825 }
1826 };
1827 Err(DeserializeError::new(
1828 "Voter",
1829 DeserializeFailure::NoVariantMatchedWithCauses(errs),
1830 ))
1831 })()
1832 .map_err(|e| e.annotate("Voter"))
1833 }
1834}
1835
1836impl Serialize for VotingProcedure {
1837 fn serialize<'se, W: Write>(
1838 &self,
1839 serializer: &'se mut Serializer<W>,
1840 force_canonical: bool,
1841 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1842 serializer.write_array_sz(
1843 self.encodings
1844 .as_ref()
1845 .map(|encs| encs.len_encoding)
1846 .unwrap_or_default()
1847 .to_len_sz(2, force_canonical),
1848 )?;
1849 match &self.vote {
1850 Vote::No => serializer.write_unsigned_integer_sz(
1851 0u64,
1852 fit_sz(
1853 0u64,
1854 self.encodings
1855 .as_ref()
1856 .map(|encs| encs.vote_encoding)
1857 .unwrap_or_default(),
1858 force_canonical,
1859 ),
1860 ),
1861 Vote::Yes => serializer.write_unsigned_integer_sz(
1862 1u64,
1863 fit_sz(
1864 1u64,
1865 self.encodings
1866 .as_ref()
1867 .map(|encs| encs.vote_encoding)
1868 .unwrap_or_default(),
1869 force_canonical,
1870 ),
1871 ),
1872 Vote::Abstain => serializer.write_unsigned_integer_sz(
1873 2u64,
1874 fit_sz(
1875 2u64,
1876 self.encodings
1877 .as_ref()
1878 .map(|encs| encs.vote_encoding)
1879 .unwrap_or_default(),
1880 force_canonical,
1881 ),
1882 ),
1883 }?;
1884 match &self.anchor {
1885 Some(x) => x.serialize(serializer, force_canonical),
1886 None => serializer.write_special(cbor_event::Special::Null),
1887 }?;
1888 self.encodings
1889 .as_ref()
1890 .map(|encs| encs.len_encoding)
1891 .unwrap_or_default()
1892 .end(serializer, force_canonical)
1893 }
1894}
1895
1896impl Deserialize for VotingProcedure {
1897 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1898 let len = raw.array_sz()?;
1899 let len_encoding: LenEncoding = len.into();
1900 let mut read_len = CBORReadLen::new(len);
1901 read_len.read_elems(2)?;
1902 read_len.finish()?;
1903 (|| -> Result<_, DeserializeError> {
1904 let (vote, vote_encoding) = (|| -> Result<_, DeserializeError> {
1905 let initial_position = raw.as_mut_ref().stream_position().unwrap();
1906 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1907 let (no_value, no_encoding) = raw.unsigned_integer_sz()?;
1908 if no_value != 0 {
1909 return Err(DeserializeFailure::FixedValueMismatch {
1910 found: Key::Uint(no_value),
1911 expected: Key::Uint(0),
1912 }
1913 .into());
1914 }
1915 Ok(Some(no_encoding))
1916 })(raw);
1917 match deser_variant {
1918 Ok(vote_encoding) => return Ok((Vote::No, vote_encoding)),
1919 Err(_) => raw
1920 .as_mut_ref()
1921 .seek(SeekFrom::Start(initial_position))
1922 .unwrap(),
1923 };
1924 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1925 let (yes_value, yes_encoding) = raw.unsigned_integer_sz()?;
1926 if yes_value != 1 {
1927 return Err(DeserializeFailure::FixedValueMismatch {
1928 found: Key::Uint(yes_value),
1929 expected: Key::Uint(1),
1930 }
1931 .into());
1932 }
1933 Ok(Some(yes_encoding))
1934 })(raw);
1935 match deser_variant {
1936 Ok(vote_encoding) => return Ok((Vote::Yes, vote_encoding)),
1937 Err(_) => raw
1938 .as_mut_ref()
1939 .seek(SeekFrom::Start(initial_position))
1940 .unwrap(),
1941 };
1942 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1943 let (abstain_value, abstain_encoding) = raw.unsigned_integer_sz()?;
1944 if abstain_value != 2 {
1945 return Err(DeserializeFailure::FixedValueMismatch {
1946 found: Key::Uint(abstain_value),
1947 expected: Key::Uint(2),
1948 }
1949 .into());
1950 }
1951 Ok(Some(abstain_encoding))
1952 })(raw);
1953 match deser_variant {
1954 Ok(vote_encoding) => return Ok((Vote::Abstain, vote_encoding)),
1955 Err(_) => raw
1956 .as_mut_ref()
1957 .seek(SeekFrom::Start(initial_position))
1958 .unwrap(),
1959 };
1960 Err(DeserializeError::new(
1961 "Vote",
1962 DeserializeFailure::NoVariantMatched,
1963 ))
1964 })()
1965 .map_err(|e| e.annotate("vote"))?;
1966 let anchor = (|| -> Result<_, DeserializeError> {
1967 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
1968 true => Some(Anchor::deserialize(raw)?),
1969 false => {
1970 if raw.special()? != cbor_event::Special::Null {
1971 return Err(DeserializeFailure::ExpectedNull.into());
1972 }
1973 None
1974 }
1975 })
1976 })()
1977 .map_err(|e| e.annotate("anchor"))?;
1978 match len {
1979 cbor_event::LenSz::Len(_, _) => (),
1980 cbor_event::LenSz::Indefinite => match raw.special()? {
1981 cbor_event::Special::Break => (),
1982 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1983 },
1984 }
1985 Ok(VotingProcedure {
1986 vote,
1987 anchor,
1988 encodings: Some(VotingProcedureEncoding {
1989 len_encoding,
1990 vote_encoding,
1991 }),
1992 })
1993 })()
1994 .map_err(|e| e.annotate("VotingProcedure"))
1995 }
1996}