1use crate::serialization::utils::check_len;
2use crate::*;
3
4impl Serialize for PoolVotingThresholds {
5 fn serialize<'se, W: Write>(
6 &self,
7 serializer: &'se mut Serializer<W>,
8 ) -> cbor_event::Result<&'se mut Serializer<W>> {
9 serializer.write_array(cbor_event::Len::Len(5))?;
10 self.motion_no_confidence.serialize(serializer)?;
11 self.committee_normal.serialize(serializer)?;
12 self.committee_no_confidence.serialize(serializer)?;
13 self.hard_fork_initiation.serialize(serializer)?;
14 self.security_relevant_threshold.serialize(serializer)
15 }
16}
17
18impl_deserialize_for_wrapped_tuple!(PoolVotingThresholds);
19
20impl DeserializeEmbeddedGroup for PoolVotingThresholds {
21 fn deserialize_as_embedded_group<R: BufRead + Seek>(
22 raw: &mut Deserializer<R>,
23 len: cbor_event::Len,
24 ) -> Result<Self, DeserializeError> {
25 check_len(
26 len,
27 5,
28 "[\
29 motion_no_confidence, \
30 committee_normal, \
31 committee_no_confidence, \
32 hard_fork_initiation, \
33 security_relevant_threshold\
34 ]",
35 )?;
36
37 let motion_no_confidence =
38 UnitInterval::deserialize(raw).map_err(|e| e.annotate("motion_no_confidence"))?;
39 let committee_normal =
40 UnitInterval::deserialize(raw).map_err(|e| e.annotate("committee_normal"))?;
41 let committee_no_confidence =
42 UnitInterval::deserialize(raw).map_err(|e| e.annotate("committee_no_confidence"))?;
43 let hard_fork_initiation =
44 UnitInterval::deserialize(raw).map_err(|e| e.annotate("hard_fork_initiation"))?;
45 let security_relevant_threshold = UnitInterval::deserialize(raw)
46 .map_err(|e| e.annotate("security_relevant_threshold"))?;
47
48 return Ok(PoolVotingThresholds {
49 motion_no_confidence,
50 committee_normal,
51 committee_no_confidence,
52 hard_fork_initiation,
53 security_relevant_threshold,
54 });
55 }
56}
57
58impl Serialize for DRepVotingThresholds {
59 fn serialize<'se, W: Write>(
60 &self,
61 serializer: &'se mut Serializer<W>,
62 ) -> cbor_event::Result<&'se mut Serializer<W>> {
63 serializer.write_array(cbor_event::Len::Len(10))?;
64 self.motion_no_confidence.serialize(serializer)?;
65 self.committee_normal.serialize(serializer)?;
66 self.committee_no_confidence.serialize(serializer)?;
67 self.update_constitution.serialize(serializer)?;
68 self.hard_fork_initiation.serialize(serializer)?;
69 self.pp_network_group.serialize(serializer)?;
70 self.pp_economic_group.serialize(serializer)?;
71 self.pp_technical_group.serialize(serializer)?;
72 self.pp_governance_group.serialize(serializer)?;
73 self.treasury_withdrawal.serialize(serializer)
74 }
75}
76
77impl_deserialize_for_wrapped_tuple!(DRepVotingThresholds);
78
79impl DeserializeEmbeddedGroup for DRepVotingThresholds {
80 fn deserialize_as_embedded_group<R: BufRead + Seek>(
81 raw: &mut Deserializer<R>,
82 len: cbor_event::Len,
83 ) -> Result<Self, DeserializeError> {
84 check_len(
85 len,
86 10,
87 "[\
88 motion_no_confidence, \
89 committee_normal, \
90 committee_no_confidence, \
91 update_constitution, \
92 hard_fork_initiation, \
93 pp_network_group, \
94 pp_economic_group, \
95 pp_technical_group, \
96 pp_governance_group, \
97 treasury_withdrawal\
98 ]",
99 )?;
100
101 let motion_no_confidence =
102 UnitInterval::deserialize(raw).map_err(|e| e.annotate("motion_no_confidence"))?;
103 let committee_normal =
104 UnitInterval::deserialize(raw).map_err(|e| e.annotate("committee_normal"))?;
105 let committee_no_confidence =
106 UnitInterval::deserialize(raw).map_err(|e| e.annotate("committee_no_confidence"))?;
107 let update_constitution =
108 UnitInterval::deserialize(raw).map_err(|e| e.annotate("update_constitution"))?;
109 let hard_fork_initiation =
110 UnitInterval::deserialize(raw).map_err(|e| e.annotate("hard_fork_initiation"))?;
111 let pp_network_group =
112 UnitInterval::deserialize(raw).map_err(|e| e.annotate("pp_network_group"))?;
113 let pp_economic_group =
114 UnitInterval::deserialize(raw).map_err(|e| e.annotate("pp_economic_group"))?;
115 let pp_technical_group =
116 UnitInterval::deserialize(raw).map_err(|e| e.annotate("pp_technical_group"))?;
117 let pp_governance_group =
118 UnitInterval::deserialize(raw).map_err(|e| e.annotate("pp_governance_group"))?;
119 let treasury_withdrawal =
120 UnitInterval::deserialize(raw).map_err(|e| e.annotate("treasury_withdrawal"))?;
121
122 return Ok(DRepVotingThresholds {
123 motion_no_confidence,
124 committee_normal,
125 committee_no_confidence,
126 update_constitution,
127 hard_fork_initiation,
128 pp_network_group,
129 pp_economic_group,
130 pp_technical_group,
131 pp_governance_group,
132 treasury_withdrawal,
133 });
134 }
135}
136
137impl cbor_event::se::Serialize for ProtocolParamUpdate {
138 fn serialize<'se, W: Write>(
139 &self,
140 serializer: &'se mut Serializer<W>,
141 ) -> cbor_event::Result<&'se mut Serializer<W>> {
142 serializer.write_map(cbor_event::Len::Len(
143 match &self.minfee_a {
144 Some(_) => 1,
145 None => 0,
146 } + match &self.minfee_b {
147 Some(_) => 1,
148 None => 0,
149 } + match &self.max_block_body_size {
150 Some(_) => 1,
151 None => 0,
152 } + match &self.max_tx_size {
153 Some(_) => 1,
154 None => 0,
155 } + match &self.max_block_header_size {
156 Some(_) => 1,
157 None => 0,
158 } + match &self.key_deposit {
159 Some(_) => 1,
160 None => 0,
161 } + match &self.pool_deposit {
162 Some(_) => 1,
163 None => 0,
164 } + match &self.max_epoch {
165 Some(_) => 1,
166 None => 0,
167 } + match &self.n_opt {
168 Some(_) => 1,
169 None => 0,
170 } + match &self.pool_pledge_influence {
171 Some(_) => 1,
172 None => 0,
173 } + match &self.expansion_rate {
174 Some(_) => 1,
175 None => 0,
176 } + match &self.treasury_growth_rate {
177 Some(_) => 1,
178 None => 0,
179 } + match &self.d {
180 Some(_) => 1,
181 None => 0,
182 } + match &self.extra_entropy {
183 Some(_) => 1,
184 None => 0,
185 } + match &self.protocol_version {
186 Some(_) => 1,
187 None => 0,
188 } + match &self.min_pool_cost {
189 Some(_) => 1,
190 None => 0,
191 } + match &self.ada_per_utxo_byte {
192 Some(_) => 1,
193 None => 0,
194 } + match &self.cost_models {
195 Some(_) => 1,
196 None => 0,
197 } + match &self.execution_costs {
198 Some(_) => 1,
199 None => 0,
200 } + match &self.max_tx_ex_units {
201 Some(_) => 1,
202 None => 0,
203 } + match &self.max_block_ex_units {
204 Some(_) => 1,
205 None => 0,
206 } + match &self.max_value_size {
207 Some(_) => 1,
208 None => 0,
209 } + match &self.collateral_percentage {
210 Some(_) => 1,
211 None => 0,
212 } + match &self.max_collateral_inputs {
213 Some(_) => 1,
214 None => 0,
215 } + match &self.pool_voting_thresholds {
216 Some(_) => 1,
217 None => 0,
218 } + match &self.drep_voting_thresholds {
219 Some(_) => 1,
220 None => 0,
221 } + match &self.min_committee_size {
222 Some(_) => 1,
223 None => 0,
224 } + match &self.committee_term_limit {
225 Some(_) => 1,
226 None => 0,
227 } + match &self.governance_action_validity_period {
228 Some(_) => 1,
229 None => 0,
230 } + match &self.governance_action_deposit {
231 Some(_) => 1,
232 None => 0,
233 } + match &self.drep_deposit {
234 Some(_) => 1,
235 None => 0,
236 } + match &self.drep_inactivity_period {
237 Some(_) => 1,
238 None => 0,
239 } + match &self.ref_script_coins_per_byte {
240 Some(_) => 1,
241 None => 0,
242 }
243 ))?;
244 if let Some(field) = &self.minfee_a {
245 serializer.write_unsigned_integer(0)?;
246 field.serialize(serializer)?;
247 }
248 if let Some(field) = &self.minfee_b {
249 serializer.write_unsigned_integer(1)?;
250 field.serialize(serializer)?;
251 }
252 if let Some(field) = &self.max_block_body_size {
253 serializer.write_unsigned_integer(2)?;
254 field.serialize(serializer)?;
255 }
256 if let Some(field) = &self.max_tx_size {
257 serializer.write_unsigned_integer(3)?;
258 field.serialize(serializer)?;
259 }
260 if let Some(field) = &self.max_block_header_size {
261 serializer.write_unsigned_integer(4)?;
262 field.serialize(serializer)?;
263 }
264 if let Some(field) = &self.key_deposit {
265 serializer.write_unsigned_integer(5)?;
266 field.serialize(serializer)?;
267 }
268 if let Some(field) = &self.pool_deposit {
269 serializer.write_unsigned_integer(6)?;
270 field.serialize(serializer)?;
271 }
272 if let Some(field) = &self.max_epoch {
273 serializer.write_unsigned_integer(7)?;
274 field.serialize(serializer)?;
275 }
276 if let Some(field) = &self.n_opt {
277 serializer.write_unsigned_integer(8)?;
278 field.serialize(serializer)?;
279 }
280 if let Some(field) = &self.pool_pledge_influence {
281 serializer.write_unsigned_integer(9)?;
282 field.serialize(serializer)?;
283 }
284 if let Some(field) = &self.expansion_rate {
285 serializer.write_unsigned_integer(10)?;
286 field.serialize(serializer)?;
287 }
288 if let Some(field) = &self.treasury_growth_rate {
289 serializer.write_unsigned_integer(11)?;
290 field.serialize(serializer)?;
291 }
292 if let Some(field) = &self.d {
293 serializer.write_unsigned_integer(12)?;
294 field.serialize(serializer)?;
295 }
296 if let Some(field) = &self.extra_entropy {
297 serializer.write_unsigned_integer(13)?;
298 field.serialize(serializer)?;
299 }
300 if let Some(field) = &self.protocol_version {
301 serializer.write_unsigned_integer(14)?;
302 field.serialize(serializer)?;
303 }
304 if let Some(field) = &self.min_pool_cost {
305 serializer.write_unsigned_integer(16)?;
306 field.serialize(serializer)?;
307 }
308 if let Some(field) = &self.ada_per_utxo_byte {
309 serializer.write_unsigned_integer(17)?;
310 field.serialize(serializer)?;
311 }
312 if let Some(field) = &self.cost_models {
313 serializer.write_unsigned_integer(18)?;
314 field.serialize(serializer)?;
315 }
316 if let Some(field) = &self.execution_costs {
317 serializer.write_unsigned_integer(19)?;
318 field.serialize(serializer)?;
319 }
320 if let Some(field) = &self.max_tx_ex_units {
321 serializer.write_unsigned_integer(20)?;
322 field.serialize(serializer)?;
323 }
324 if let Some(field) = &self.max_block_ex_units {
325 serializer.write_unsigned_integer(21)?;
326 field.serialize(serializer)?;
327 }
328 if let Some(field) = &self.max_value_size {
329 serializer.write_unsigned_integer(22)?;
330 field.serialize(serializer)?;
331 }
332 if let Some(field) = &self.collateral_percentage {
333 serializer.write_unsigned_integer(23)?;
334 field.serialize(serializer)?;
335 }
336 if let Some(field) = &self.max_collateral_inputs {
337 serializer.write_unsigned_integer(24)?;
338 field.serialize(serializer)?;
339 }
340 if let Some(field) = &self.pool_voting_thresholds {
341 serializer.write_unsigned_integer(25)?;
342 field.serialize(serializer)?;
343 }
344 if let Some(field) = &self.drep_voting_thresholds {
345 serializer.write_unsigned_integer(26)?;
346 field.serialize(serializer)?;
347 }
348 if let Some(field) = &self.min_committee_size {
349 serializer.write_unsigned_integer(27)?;
350 field.serialize(serializer)?;
351 }
352 if let Some(field) = &self.committee_term_limit {
353 serializer.write_unsigned_integer(28)?;
354 field.serialize(serializer)?;
355 }
356 if let Some(field) = &self.governance_action_validity_period {
357 serializer.write_unsigned_integer(29)?;
358 field.serialize(serializer)?;
359 }
360 if let Some(field) = &self.governance_action_deposit {
361 serializer.write_unsigned_integer(30)?;
362 field.serialize(serializer)?;
363 }
364 if let Some(field) = &self.drep_deposit {
365 serializer.write_unsigned_integer(31)?;
366 field.serialize(serializer)?;
367 }
368 if let Some(field) = &self.drep_inactivity_period {
369 serializer.write_unsigned_integer(32)?;
370 field.serialize(serializer)?;
371 }
372 if let Some(field) = &self.ref_script_coins_per_byte {
373 serializer.write_unsigned_integer(33)?;
374 field.serialize(serializer)?;
375 }
376 Ok(serializer)
377 }
378}
379
380impl Deserialize for ProtocolParamUpdate {
381 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
382 (|| -> Result<_, DeserializeError> {
383 let len = raw.map()?;
384 let mut read_len = CBORReadLen::new(len);
385 let mut minfee_a = None;
386 let mut minfee_b = None;
387 let mut max_block_body_size = None;
388 let mut max_tx_size = None;
389 let mut max_block_header_size = None;
390 let mut key_deposit = None;
391 let mut pool_deposit = None;
392 let mut max_epoch = None;
393 let mut n_opt = None;
394 let mut pool_pledge_influence = None;
395 let mut expansion_rate = None;
396 let mut treasury_growth_rate = None;
397 let mut d = None;
398 let mut extra_entropy = None;
399 let mut protocol_version = None;
400 let mut min_pool_cost = None;
401 let mut ada_per_utxo_byte = None;
402 let mut cost_models = None;
403 let mut execution_costs = None;
404 let mut max_tx_ex_units = None;
405 let mut max_block_ex_units = None;
406 let mut max_value_size = None;
407 let mut collateral_percentage = None;
408 let mut max_collateral_inputs = None;
409 let mut pool_voting_thresholds = None;
410 let mut drep_voting_thresholds = None;
411 let mut min_committee_size = None;
412 let mut committee_term_limit = None;
413 let mut governance_action_validity_period = None;
414 let mut governance_action_deposit = None;
415 let mut drep_deposit = None;
416 let mut drep_inactivity_period = None;
417 let mut ref_script_coins_per_byte = None;
418
419 let mut read = 0;
420 while match len {
421 cbor_event::Len::Len(n) => read < n as usize,
422 cbor_event::Len::Indefinite => true,
423 } {
424 match raw.cbor_type()? {
425 CBORType::UnsignedInteger => match raw.unsigned_integer()? {
426 0 => {
427 if minfee_a.is_some() {
428 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
429 }
430 minfee_a = Some(
431 (|| -> Result<_, DeserializeError> {
432 read_len.read_elems(1)?;
433 Ok(Coin::deserialize(raw)?)
434 })()
435 .map_err(|e| e.annotate("minfee_a"))?,
436 );
437 }
438 1 => {
439 if minfee_b.is_some() {
440 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
441 }
442 minfee_b = Some(
443 (|| -> Result<_, DeserializeError> {
444 read_len.read_elems(1)?;
445 Ok(Coin::deserialize(raw)?)
446 })()
447 .map_err(|e| e.annotate("minfee_b"))?,
448 );
449 }
450 2 => {
451 if max_block_body_size.is_some() {
452 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
453 }
454 max_block_body_size = Some(
455 (|| -> Result<_, DeserializeError> {
456 read_len.read_elems(1)?;
457 Ok(u32::deserialize(raw)?)
458 })()
459 .map_err(|e| e.annotate("max_block_body_size"))?,
460 );
461 }
462 3 => {
463 if max_tx_size.is_some() {
464 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
465 }
466 max_tx_size = Some(
467 (|| -> Result<_, DeserializeError> {
468 read_len.read_elems(1)?;
469 Ok(u32::deserialize(raw)?)
470 })()
471 .map_err(|e| e.annotate("max_tx_size"))?,
472 );
473 }
474 4 => {
475 if max_block_header_size.is_some() {
476 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
477 }
478 max_block_header_size = Some(
479 (|| -> Result<_, DeserializeError> {
480 read_len.read_elems(1)?;
481 Ok(u32::deserialize(raw)?)
482 })()
483 .map_err(|e| e.annotate("max_block_header_size"))?,
484 );
485 }
486 5 => {
487 if key_deposit.is_some() {
488 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
489 }
490 key_deposit = Some(
491 (|| -> Result<_, DeserializeError> {
492 read_len.read_elems(1)?;
493 Ok(Coin::deserialize(raw)?)
494 })()
495 .map_err(|e| e.annotate("key_deposit"))?,
496 );
497 }
498 6 => {
499 if pool_deposit.is_some() {
500 return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
501 }
502 pool_deposit = Some(
503 (|| -> Result<_, DeserializeError> {
504 read_len.read_elems(1)?;
505 Ok(Coin::deserialize(raw)?)
506 })()
507 .map_err(|e| e.annotate("pool_deposit"))?,
508 );
509 }
510 7 => {
511 if max_epoch.is_some() {
512 return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
513 }
514 max_epoch = Some(
515 (|| -> Result<_, DeserializeError> {
516 read_len.read_elems(1)?;
517 Ok(Epoch::deserialize(raw)?)
518 })()
519 .map_err(|e| e.annotate("max_epoch"))?,
520 );
521 }
522 8 => {
523 if n_opt.is_some() {
524 return Err(DeserializeFailure::DuplicateKey(Key::Uint(8)).into());
525 }
526 n_opt = Some(
527 (|| -> Result<_, DeserializeError> {
528 read_len.read_elems(1)?;
529 Ok(u32::deserialize(raw)?)
530 })()
531 .map_err(|e| e.annotate("n_opt"))?,
532 );
533 }
534 9 => {
535 if pool_pledge_influence.is_some() {
536 return Err(DeserializeFailure::DuplicateKey(Key::Uint(9)).into());
537 }
538 pool_pledge_influence = Some(
539 (|| -> Result<_, DeserializeError> {
540 read_len.read_elems(1)?;
541 Ok(UnitInterval::deserialize(raw)?)
542 })()
543 .map_err(|e| e.annotate("pool_pledge_influence"))?,
544 );
545 }
546 10 => {
547 if expansion_rate.is_some() {
548 return Err(DeserializeFailure::DuplicateKey(Key::Uint(10)).into());
549 }
550 expansion_rate = Some(
551 (|| -> Result<_, DeserializeError> {
552 read_len.read_elems(1)?;
553 Ok(UnitInterval::deserialize(raw)?)
554 })()
555 .map_err(|e| e.annotate("expansion_rate"))?,
556 );
557 }
558 11 => {
559 if treasury_growth_rate.is_some() {
560 return Err(DeserializeFailure::DuplicateKey(Key::Uint(11)).into());
561 }
562 treasury_growth_rate = Some(
563 (|| -> Result<_, DeserializeError> {
564 read_len.read_elems(1)?;
565 Ok(UnitInterval::deserialize(raw)?)
566 })()
567 .map_err(|e| e.annotate("treasury_growth_rate"))?,
568 );
569 }
570 12 => {
571 if d.is_some() {
572 return Err(DeserializeFailure::DuplicateKey(Key::Uint(12)).into());
573 }
574 d = Some(
575 (|| -> Result<_, DeserializeError> {
576 read_len.read_elems(1)?;
577 Ok(UnitInterval::deserialize(raw)?)
578 })()
579 .map_err(|e| e.annotate("d"))?,
580 );
581 }
582 13 => {
583 if extra_entropy.is_some() {
584 return Err(DeserializeFailure::DuplicateKey(Key::Uint(13)).into());
585 }
586 extra_entropy = Some(
587 (|| -> Result<_, DeserializeError> {
588 read_len.read_elems(1)?;
589 Ok(Nonce::deserialize(raw)?)
590 })()
591 .map_err(|e| e.annotate("extra_entropy"))?,
592 );
593 }
594 14 => {
595 if protocol_version.is_some() {
596 return Err(DeserializeFailure::DuplicateKey(Key::Uint(14)).into());
597 }
598 protocol_version = Some(
599 (|| -> Result<_, DeserializeError> {
600 read_len.read_elems(1)?;
601 Ok(ProtocolVersion::deserialize(raw)?)
602 })()
603 .map_err(|e| e.annotate("protocol_version"))?,
604 );
605 }
606 16 => {
607 if min_pool_cost.is_some() {
608 return Err(DeserializeFailure::DuplicateKey(Key::Uint(16)).into());
609 }
610 min_pool_cost = Some(
611 (|| -> Result<_, DeserializeError> {
612 read_len.read_elems(1)?;
613 Ok(Coin::deserialize(raw)?)
614 })()
615 .map_err(|e| e.annotate("min_pool_cost"))?,
616 );
617 }
618 17 => {
619 if ada_per_utxo_byte.is_some() {
620 return Err(DeserializeFailure::DuplicateKey(Key::Uint(17)).into());
621 }
622 ada_per_utxo_byte = Some(
623 (|| -> Result<_, DeserializeError> {
624 read_len.read_elems(1)?;
625 Ok(Coin::deserialize(raw)?)
626 })()
627 .map_err(|e| e.annotate("ada_per_utxo_byte"))?,
628 );
629 }
630 18 => {
631 if cost_models.is_some() {
632 return Err(DeserializeFailure::DuplicateKey(Key::Uint(18)).into());
633 }
634 cost_models = Some(
635 (|| -> Result<_, DeserializeError> {
636 read_len.read_elems(1)?;
637 Ok(Costmdls::deserialize(raw)?)
638 })()
639 .map_err(|e| e.annotate("cost_models"))?,
640 );
641 }
642 19 => {
643 if execution_costs.is_some() {
644 return Err(DeserializeFailure::DuplicateKey(Key::Uint(19)).into());
645 }
646 execution_costs = Some(
647 (|| -> Result<_, DeserializeError> {
648 read_len.read_elems(1)?;
649 Ok(ExUnitPrices::deserialize(raw)?)
650 })()
651 .map_err(|e| e.annotate("execution_costs"))?,
652 );
653 }
654 20 => {
655 if max_tx_ex_units.is_some() {
656 return Err(DeserializeFailure::DuplicateKey(Key::Uint(20)).into());
657 }
658 max_tx_ex_units = Some(
659 (|| -> Result<_, DeserializeError> {
660 read_len.read_elems(1)?;
661 Ok(ExUnits::deserialize(raw)?)
662 })()
663 .map_err(|e| e.annotate("max_tx_ex_units"))?,
664 );
665 }
666 21 => {
667 if max_block_ex_units.is_some() {
668 return Err(DeserializeFailure::DuplicateKey(Key::Uint(21)).into());
669 }
670 max_block_ex_units = Some(
671 (|| -> Result<_, DeserializeError> {
672 read_len.read_elems(1)?;
673 Ok(ExUnits::deserialize(raw)?)
674 })()
675 .map_err(|e| e.annotate("max_block_ex_units"))?,
676 );
677 }
678 22 => {
679 if max_value_size.is_some() {
680 return Err(DeserializeFailure::DuplicateKey(Key::Uint(22)).into());
681 }
682 max_value_size = Some(
683 (|| -> Result<_, DeserializeError> {
684 read_len.read_elems(1)?;
685 Ok(u32::deserialize(raw)?)
686 })()
687 .map_err(|e| e.annotate("max_value_size"))?,
688 );
689 }
690 23 => {
691 if collateral_percentage.is_some() {
692 return Err(DeserializeFailure::DuplicateKey(Key::Uint(23)).into());
693 }
694 collateral_percentage = Some(
695 (|| -> Result<_, DeserializeError> {
696 read_len.read_elems(1)?;
697 Ok(u32::deserialize(raw)?)
698 })()
699 .map_err(|e| e.annotate("collateral_percentage"))?,
700 );
701 }
702 24 => {
703 if max_collateral_inputs.is_some() {
704 return Err(DeserializeFailure::DuplicateKey(Key::Uint(24)).into());
705 }
706 max_collateral_inputs = Some(
707 (|| -> Result<_, DeserializeError> {
708 read_len.read_elems(1)?;
709 Ok(u32::deserialize(raw)?)
710 })()
711 .map_err(|e| e.annotate("max_collateral_inputs"))?,
712 );
713 }
714 25 => {
715 if pool_voting_thresholds.is_some() {
716 return Err(DeserializeFailure::DuplicateKey(Key::Uint(25)).into());
717 }
718 pool_voting_thresholds = Some(
719 (|| -> Result<_, DeserializeError> {
720 read_len.read_elems(1)?;
721 Ok(PoolVotingThresholds::deserialize(raw)?)
722 })()
723 .map_err(|e| e.annotate("pool_voting_thresholds"))?,
724 );
725 }
726 26 => {
727 if drep_voting_thresholds.is_some() {
728 return Err(DeserializeFailure::DuplicateKey(Key::Uint(26)).into());
729 }
730 drep_voting_thresholds = Some(
731 (|| -> Result<_, DeserializeError> {
732 read_len.read_elems(1)?;
733 Ok(DRepVotingThresholds::deserialize(raw)?)
734 })()
735 .map_err(|e| e.annotate("drep_voting_thresholds"))?,
736 );
737 }
738 27 => {
739 if min_committee_size.is_some() {
740 return Err(DeserializeFailure::DuplicateKey(Key::Uint(27)).into());
741 }
742 min_committee_size = Some(
743 (|| -> Result<_, DeserializeError> {
744 read_len.read_elems(1)?;
745 Ok(u32::deserialize(raw)?)
746 })()
747 .map_err(|e| e.annotate("min_committee_size"))?,
748 );
749 }
750 28 => {
751 if committee_term_limit.is_some() {
752 return Err(DeserializeFailure::DuplicateKey(Key::Uint(28)).into());
753 }
754 committee_term_limit = Some(
755 (|| -> Result<_, DeserializeError> {
756 read_len.read_elems(1)?;
757 Ok(Epoch::deserialize(raw)?)
758 })()
759 .map_err(|e| e.annotate("committee_term_limit"))?,
760 );
761 }
762 29 => {
763 if governance_action_validity_period.is_some() {
764 return Err(DeserializeFailure::DuplicateKey(Key::Uint(29)).into());
765 }
766 governance_action_validity_period = Some(
767 (|| -> Result<_, DeserializeError> {
768 read_len.read_elems(1)?;
769 Ok(Epoch::deserialize(raw)?)
770 })()
771 .map_err(|e| e.annotate("governance_action_validity_period"))?,
772 );
773 }
774 30 => {
775 if governance_action_deposit.is_some() {
776 return Err(DeserializeFailure::DuplicateKey(Key::Uint(30)).into());
777 }
778 governance_action_deposit = Some(
779 (|| -> Result<_, DeserializeError> {
780 read_len.read_elems(1)?;
781 Ok(Coin::deserialize(raw)?)
782 })()
783 .map_err(|e| e.annotate("governance_action_deposit"))?,
784 );
785 }
786 31 => {
787 if drep_deposit.is_some() {
788 return Err(DeserializeFailure::DuplicateKey(Key::Uint(31)).into());
789 }
790 drep_deposit = Some(
791 (|| -> Result<_, DeserializeError> {
792 read_len.read_elems(1)?;
793 Ok(Coin::deserialize(raw)?)
794 })()
795 .map_err(|e| e.annotate("drep_deposit"))?,
796 );
797 }
798 32 => {
799 if drep_inactivity_period.is_some() {
800 return Err(DeserializeFailure::DuplicateKey(Key::Uint(32)).into());
801 }
802 drep_inactivity_period = Some(
803 (|| -> Result<_, DeserializeError> {
804 read_len.read_elems(1)?;
805 Ok(Epoch::deserialize(raw)?)
806 })()
807 .map_err(|e| e.annotate("drep_inactivity_period"))?,
808 );
809 }
810 33 => {
811 if ref_script_coins_per_byte.is_some() {
812 return Err(DeserializeFailure::DuplicateKey(Key::Uint(33)).into());
813 }
814 ref_script_coins_per_byte = Some(
815 (|| -> Result<_, DeserializeError> {
816 read_len.read_elems(1)?;
817 Ok(UnitInterval::deserialize(raw)?)
818 })()
819 .map_err(|e| e.annotate("ref_script_coins_per_byte"))?,
820 );
821 }
822 unknown_key => {
823 return Err(
824 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
825 )
826 }
827 },
828 CBORType::Text => match raw.text()?.as_str() {
829 unknown_key => {
830 return Err(DeserializeFailure::UnknownKey(Key::Str(
831 unknown_key.to_owned(),
832 ))
833 .into())
834 }
835 },
836 CBORType::Special => match len {
837 cbor_event::Len::Len(_) => {
838 return Err(DeserializeFailure::BreakInDefiniteLen.into())
839 }
840 cbor_event::Len::Indefinite => match raw.special()? {
841 CBORSpecial::Break => break,
842 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
843 },
844 },
845 other_type => {
846 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
847 }
848 }
849 read += 1;
850 }
851 read_len.finish()?;
852 Ok(Self {
853 minfee_a,
854 minfee_b,
855 max_block_body_size,
856 max_tx_size,
857 max_block_header_size,
858 key_deposit,
859 pool_deposit,
860 max_epoch,
861 n_opt,
862 pool_pledge_influence,
863 expansion_rate,
864 treasury_growth_rate,
865 d,
866 extra_entropy,
867 protocol_version,
868 min_pool_cost,
869 ada_per_utxo_byte,
870 cost_models,
871 execution_costs,
872 max_tx_ex_units,
873 max_block_ex_units,
874 max_value_size,
875 collateral_percentage,
876 max_collateral_inputs,
877 pool_voting_thresholds,
878 drep_voting_thresholds,
879 min_committee_size,
880 committee_term_limit,
881 governance_action_validity_period,
882 governance_action_deposit,
883 drep_deposit,
884 drep_inactivity_period,
885 ref_script_coins_per_byte,
886 })
887 })()
888 .map_err(|e| e.annotate("ProtocolParamUpdate"))
889 }
890}