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