1use cml_core::{
5 serialization::{fit_sz, CBORReadLen, Deserialize, Serialize},
6 Key,
7};
8
9use cml_crypto::{Ed25519Signature, PublicKey, RawBytesEncoding};
10
11use super::cbor_encodings::*;
12use super::*;
13use cbor_event;
14use cbor_event::de::Deserializer;
15use cbor_event::se::Serializer;
16use std::io::{BufRead, Seek, SeekFrom, Write};
17
18impl Serialize for CIP36Delegation {
19 fn serialize<'se, W: Write>(
20 &self,
21 serializer: &'se mut Serializer<W>,
22 force_canonical: bool,
23 ) -> cbor_event::Result<&'se mut Serializer<W>> {
24 serializer.write_array_sz(
25 self.encodings
26 .as_ref()
27 .map(|encs| encs.len_encoding)
28 .unwrap_or_default()
29 .to_len_sz(2, force_canonical),
30 )?;
31 serializer.write_bytes_sz(
32 self.voting_pub_key.to_raw_bytes(),
33 self.encodings
34 .as_ref()
35 .map(|encs| encs.voting_pub_key_encoding.clone())
36 .unwrap_or_default()
37 .to_str_len_sz(
38 self.voting_pub_key.to_raw_bytes().len() as u64,
39 force_canonical,
40 ),
41 )?;
42 serializer.write_unsigned_integer_sz(
43 self.weight as u64,
44 fit_sz(
45 self.weight as u64,
46 self.encodings
47 .as_ref()
48 .map(|encs| encs.weight_encoding)
49 .unwrap_or_default(),
50 force_canonical,
51 ),
52 )?;
53 self.encodings
54 .as_ref()
55 .map(|encs| encs.len_encoding)
56 .unwrap_or_default()
57 .end(serializer, force_canonical)
58 }
59}
60
61impl Deserialize for CIP36Delegation {
62 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
63 let len = raw.array_sz()?;
64 let len_encoding: LenEncoding = len.into();
65 let mut read_len = CBORReadLen::new(len);
66 read_len.read_elems(2)?;
67 (|| -> Result<_, DeserializeError> {
68 let (voting_pub_key, voting_pub_key_encoding) = raw
69 .bytes_sz()
70 .map_err(Into::<DeserializeError>::into)
71 .and_then(|(bytes, enc)| {
72 PublicKey::from_raw_bytes(&bytes)
73 .map(|bytes| (bytes, StringEncoding::from(enc)))
74 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
75 })
76 .map_err(|e: DeserializeError| e.annotate("voting_pub_key"))?;
77 let (weight, weight_encoding) = raw
78 .unsigned_integer_sz()
79 .map(|(x, enc)| (x as u32, Some(enc)))
80 .map_err(Into::<DeserializeError>::into)
81 .map_err(|e: DeserializeError| e.annotate("weight"))?;
82 match len {
83 cbor_event::LenSz::Len(_, _) => (),
84 cbor_event::LenSz::Indefinite => match raw.special()? {
85 cbor_event::Special::Break => (),
86 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
87 },
88 }
89 Ok(CIP36Delegation {
90 voting_pub_key,
91 weight,
92 encodings: Some(CIP36DelegationEncoding {
93 len_encoding,
94 voting_pub_key_encoding,
95 weight_encoding,
96 }),
97 })
98 })()
99 .map_err(|e| e.annotate("CIP36Delegation"))
100 }
101}
102
103impl Serialize for CIP36DelegationDistribution {
104 fn serialize<'se, W: Write>(
105 &self,
106 serializer: &'se mut Serializer<W>,
107 force_canonical: bool,
108 ) -> cbor_event::Result<&'se mut Serializer<W>> {
109 match self {
110 CIP36DelegationDistribution::Weighted {
111 delegations,
112 delegations_encoding,
113 } => {
114 serializer.write_array_sz(
115 delegations_encoding.to_len_sz(delegations.len() as u64, force_canonical),
116 )?;
117 for element in delegations.iter() {
118 element.serialize(serializer, force_canonical)?;
119 }
120 delegations_encoding.end(serializer, force_canonical)
121 }
122 CIP36DelegationDistribution::Legacy {
123 legacy,
124 legacy_encoding,
125 } => serializer.write_bytes_sz(
126 legacy.to_raw_bytes(),
127 legacy_encoding.to_str_len_sz(legacy.to_raw_bytes().len() as u64, force_canonical),
128 ),
129 }
130 }
131}
132
133impl Deserialize for CIP36DelegationDistribution {
134 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
135 (|| -> Result<_, DeserializeError> {
136 let initial_position = raw.as_mut_ref().stream_position().unwrap();
137 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
138 let mut weighted_arr = Vec::new();
139 let len = raw.array_sz()?;
140 let delegations_encoding = len.into();
141 while match len {
142 cbor_event::LenSz::Len(n, _) => (weighted_arr.len() as u64) < n,
143 cbor_event::LenSz::Indefinite => true,
144 } {
145 if raw.cbor_type()? == cbor_event::Type::Special {
146 assert_eq!(raw.special()?, cbor_event::Special::Break);
147 break;
148 }
149 weighted_arr.push(CIP36Delegation::deserialize(raw)?);
150 }
151 Ok((weighted_arr, delegations_encoding))
152 })(raw);
153 match deser_variant {
154 Ok((delegations, delegations_encoding)) => {
155 return Ok(Self::Weighted {
156 delegations,
157 delegations_encoding,
158 })
159 }
160 Err(_) => raw
161 .as_mut_ref()
162 .seek(SeekFrom::Start(initial_position))
163 .unwrap(),
164 };
165 let deser_variant: Result<_, DeserializeError> = raw
166 .bytes_sz()
167 .map_err(Into::<DeserializeError>::into)
168 .and_then(|(bytes, enc)| {
169 PublicKey::from_raw_bytes(&bytes)
170 .map(|bytes| (bytes, StringEncoding::from(enc)))
171 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
172 });
173 match deser_variant {
174 Ok((legacy, legacy_encoding)) => {
175 return Ok(Self::Legacy {
176 legacy,
177 legacy_encoding,
178 })
179 }
180 Err(_) => raw
181 .as_mut_ref()
182 .seek(SeekFrom::Start(initial_position))
183 .unwrap(),
184 };
185 Err(DeserializeError::new(
186 "CIP36DelegationDistribution",
187 DeserializeFailure::NoVariantMatched,
188 ))
189 })()
190 .map_err(|e| e.annotate("CIP36DelegationDistribution"))
191 }
192}
193
194impl Serialize for CIP36DeregistrationWitness {
195 fn serialize<'se, W: Write>(
196 &self,
197 serializer: &'se mut Serializer<W>,
198 force_canonical: bool,
199 ) -> cbor_event::Result<&'se mut Serializer<W>> {
200 serializer.write_map_sz(
201 self.encodings
202 .as_ref()
203 .map(|encs| encs.len_encoding)
204 .unwrap_or_default()
205 .to_len_sz(1, force_canonical),
206 )?;
207 let deser_order = self
208 .encodings
209 .as_ref()
210 .filter(|encs| !force_canonical && encs.orig_deser_order.len() == 1)
211 .map(|encs| encs.orig_deser_order.clone())
212 .unwrap_or_else(|| vec![0]);
213 for field_index in deser_order {
214 match field_index {
215 0 => {
216 serializer.write_unsigned_integer_sz(
217 1u64,
218 fit_sz(
219 1u64,
220 self.encodings
221 .as_ref()
222 .map(|encs| encs.stake_witness_key_encoding)
223 .unwrap_or_default(),
224 force_canonical,
225 ),
226 )?;
227 serializer.write_bytes_sz(
228 self.stake_witness.to_raw_bytes(),
229 self.encodings
230 .as_ref()
231 .map(|encs| encs.stake_witness_encoding.clone())
232 .unwrap_or_default()
233 .to_str_len_sz(
234 self.stake_witness.to_raw_bytes().len() as u64,
235 force_canonical,
236 ),
237 )?;
238 }
239 _ => unreachable!(),
240 };
241 }
242 self.encodings
243 .as_ref()
244 .map(|encs| encs.len_encoding)
245 .unwrap_or_default()
246 .end(serializer, force_canonical)
247 }
248}
249
250impl Deserialize for CIP36DeregistrationWitness {
251 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
252 let len = raw.map_sz()?;
253 let len_encoding: LenEncoding = len.into();
254 let mut read_len = CBORReadLen::new(len);
255 read_len.read_elems(1)?;
256 (|| -> Result<_, DeserializeError> {
257 let mut orig_deser_order = Vec::new();
258 let mut stake_witness_encoding = StringEncoding::default();
259 let mut stake_witness_key_encoding = None;
260 let mut stake_witness = None;
261 let mut read = 0;
262 while match len {
263 cbor_event::LenSz::Len(n, _) => read < n,
264 cbor_event::LenSz::Indefinite => true,
265 } {
266 match raw.cbor_type()? {
267 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
268 (1, key_enc) => {
269 if stake_witness.is_some() {
270 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
271 }
272 let (tmp_stake_witness, tmp_stake_witness_encoding) = raw
273 .bytes_sz()
274 .map_err(Into::<DeserializeError>::into)
275 .and_then(|(bytes, enc)| {
276 Ed25519Signature::from_raw_bytes(&bytes)
277 .map(|bytes| (bytes, StringEncoding::from(enc)))
278 .map_err(|e| {
279 DeserializeFailure::InvalidStructure(Box::new(e)).into()
280 })
281 })
282 .map_err(|e: DeserializeError| e.annotate("stake_witness"))?;
283 stake_witness = Some(tmp_stake_witness);
284 stake_witness_encoding = tmp_stake_witness_encoding;
285 stake_witness_key_encoding = Some(key_enc);
286 orig_deser_order.push(0);
287 }
288 (unknown_key, _enc) => {
289 return Err(
290 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
291 )
292 }
293 },
294 cbor_event::Type::Text => {
295 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
296 }
297 cbor_event::Type::Special => match len {
298 cbor_event::LenSz::Len(_, _) => {
299 return Err(DeserializeFailure::BreakInDefiniteLen.into())
300 }
301 cbor_event::LenSz::Indefinite => match raw.special()? {
302 cbor_event::Special::Break => break,
303 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
304 },
305 },
306 other_type => {
307 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
308 }
309 }
310 read += 1;
311 }
312 let stake_witness = match stake_witness {
313 Some(x) => x,
314 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
315 };
316 Ok(Self {
317 stake_witness,
318 encodings: Some(CIP36DeregistrationWitnessEncoding {
319 len_encoding,
320 orig_deser_order,
321 stake_witness_key_encoding,
322 stake_witness_encoding,
323 }),
324 })
325 })()
326 .map_err(|e| e.annotate("CIP36DeregistrationWitness"))
327 }
328}
329
330impl Serialize for CIP36KeyDeregistration {
331 fn serialize<'se, W: Write>(
332 &self,
333 serializer: &'se mut Serializer<W>,
334 force_canonical: bool,
335 ) -> cbor_event::Result<&'se mut Serializer<W>> {
336 serializer.write_map_sz(
337 self.encodings
338 .as_ref()
339 .map(|encs| encs.len_encoding)
340 .unwrap_or_default()
341 .to_len_sz(
342 2 + if self.voting_purpose != 0
343 || self
344 .encodings
345 .as_ref()
346 .map(|encs| encs.voting_purpose_default_present)
347 .unwrap_or(false)
348 {
349 1
350 } else {
351 0
352 },
353 force_canonical,
354 ),
355 )?;
356 let deser_order = self
357 .encodings
358 .as_ref()
359 .filter(|encs| {
360 !force_canonical
361 && encs.orig_deser_order.len()
362 == 2 + if self.voting_purpose != 0
363 || self
364 .encodings
365 .as_ref()
366 .map(|encs| encs.voting_purpose_default_present)
367 .unwrap_or(false)
368 {
369 1
370 } else {
371 0
372 }
373 })
374 .map(|encs| encs.orig_deser_order.clone())
375 .unwrap_or_else(|| vec![0, 1, 2]);
376 for field_index in deser_order {
377 match field_index {
378 0 => {
379 serializer.write_unsigned_integer_sz(
380 1u64,
381 fit_sz(
382 1u64,
383 self.encodings
384 .as_ref()
385 .map(|encs| encs.stake_credential_key_encoding)
386 .unwrap_or_default(),
387 force_canonical,
388 ),
389 )?;
390 serializer.write_bytes_sz(
391 self.stake_credential.to_raw_bytes(),
392 self.encodings
393 .as_ref()
394 .map(|encs| encs.stake_credential_encoding.clone())
395 .unwrap_or_default()
396 .to_str_len_sz(
397 self.stake_credential.to_raw_bytes().len() as u64,
398 force_canonical,
399 ),
400 )?;
401 }
402 1 => {
403 serializer.write_unsigned_integer_sz(
404 2u64,
405 fit_sz(
406 2u64,
407 self.encodings
408 .as_ref()
409 .map(|encs| encs.nonce_key_encoding)
410 .unwrap_or_default(),
411 force_canonical,
412 ),
413 )?;
414 serializer.write_unsigned_integer_sz(
415 self.nonce,
416 fit_sz(
417 self.nonce,
418 self.encodings
419 .as_ref()
420 .map(|encs| encs.nonce_encoding)
421 .unwrap_or_default(),
422 force_canonical,
423 ),
424 )?;
425 }
426 2 => {
427 serializer.write_unsigned_integer_sz(
428 3u64,
429 fit_sz(
430 3u64,
431 self.encodings
432 .as_ref()
433 .map(|encs| encs.voting_purpose_key_encoding)
434 .unwrap_or_default(),
435 force_canonical,
436 ),
437 )?;
438 serializer.write_unsigned_integer_sz(
439 self.voting_purpose,
440 fit_sz(
441 self.voting_purpose,
442 self.encodings
443 .as_ref()
444 .map(|encs| encs.voting_purpose_encoding)
445 .unwrap_or_default(),
446 force_canonical,
447 ),
448 )?;
449 }
450 _ => unreachable!(),
451 };
452 }
453 self.encodings
454 .as_ref()
455 .map(|encs| encs.len_encoding)
456 .unwrap_or_default()
457 .end(serializer, force_canonical)
458 }
459}
460
461impl Deserialize for CIP36KeyDeregistration {
462 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
463 let len = raw.map_sz()?;
464 let len_encoding: LenEncoding = len.into();
465 let mut read_len = CBORReadLen::new(len);
466 read_len.read_elems(2)?;
467 (|| -> Result<_, DeserializeError> {
468 let mut orig_deser_order = Vec::new();
469 let mut stake_credential_encoding = StringEncoding::default();
470 let mut stake_credential_key_encoding = None;
471 let mut stake_credential = None;
472 let mut nonce_encoding = None;
473 let mut nonce_key_encoding = None;
474 let mut nonce = None;
475 let mut voting_purpose_encoding = None;
476 let mut voting_purpose_default_present = false;
477 let mut voting_purpose_key_encoding = None;
478 let mut voting_purpose = None;
479 let mut read = 0;
480 while match len {
481 cbor_event::LenSz::Len(n, _) => read < n,
482 cbor_event::LenSz::Indefinite => true,
483 } {
484 match raw.cbor_type()? {
485 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
486 (1, key_enc) => {
487 if stake_credential.is_some() {
488 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
489 }
490 let (tmp_stake_credential, tmp_stake_credential_encoding) = raw
491 .bytes_sz()
492 .map_err(Into::<DeserializeError>::into)
493 .and_then(|(bytes, enc)| {
494 PublicKey::from_raw_bytes(&bytes)
495 .map(|bytes| (bytes, StringEncoding::from(enc)))
496 .map_err(|e| {
497 DeserializeFailure::InvalidStructure(Box::new(e)).into()
498 })
499 })
500 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
501 stake_credential = Some(tmp_stake_credential);
502 stake_credential_encoding = tmp_stake_credential_encoding;
503 stake_credential_key_encoding = Some(key_enc);
504 orig_deser_order.push(0);
505 }
506 (2, key_enc) => {
507 if nonce.is_some() {
508 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
509 }
510 let (tmp_nonce, tmp_nonce_encoding) = raw
511 .unsigned_integer_sz()
512 .map(|(x, enc)| (x, Some(enc)))
513 .map_err(Into::<DeserializeError>::into)
514 .map_err(|e: DeserializeError| e.annotate("nonce"))?;
515 nonce = Some(tmp_nonce);
516 nonce_encoding = tmp_nonce_encoding;
517 nonce_key_encoding = Some(key_enc);
518 orig_deser_order.push(1);
519 }
520 (3, key_enc) => {
521 if voting_purpose.is_some() {
522 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
523 }
524 let (tmp_voting_purpose, tmp_voting_purpose_encoding) =
525 (|| -> Result<_, DeserializeError> {
526 read_len.read_elems(1)?;
527 raw.unsigned_integer_sz()
528 .map(|(x, enc)| (x, Some(enc)))
529 .map_err(Into::<DeserializeError>::into)
530 })()
531 .map_err(|e| e.annotate("voting_purpose"))?;
532 voting_purpose = Some(tmp_voting_purpose);
533 voting_purpose_encoding = tmp_voting_purpose_encoding;
534 voting_purpose_key_encoding = Some(key_enc);
535 orig_deser_order.push(2);
536 }
537 (unknown_key, _enc) => {
538 return Err(
539 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
540 )
541 }
542 },
543 cbor_event::Type::Text => {
544 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
545 }
546 cbor_event::Type::Special => match len {
547 cbor_event::LenSz::Len(_, _) => {
548 return Err(DeserializeFailure::BreakInDefiniteLen.into())
549 }
550 cbor_event::LenSz::Indefinite => match raw.special()? {
551 cbor_event::Special::Break => break,
552 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
553 },
554 },
555 other_type => {
556 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
557 }
558 }
559 read += 1;
560 }
561 let stake_credential = match stake_credential {
562 Some(x) => x,
563 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
564 };
565 let nonce = match nonce {
566 Some(x) => x,
567 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(2)).into()),
568 };
569 if voting_purpose == Some(0) {
570 voting_purpose_default_present = true;
571 }
572 let voting_purpose = voting_purpose.unwrap_or(0);
573 read_len.finish()?;
574 Ok(Self {
575 stake_credential,
576 nonce,
577 voting_purpose,
578 encodings: Some(CIP36KeyDeregistrationEncoding {
579 len_encoding,
580 orig_deser_order,
581 stake_credential_key_encoding,
582 stake_credential_encoding,
583 nonce_key_encoding,
584 nonce_encoding,
585 voting_purpose_key_encoding,
586 voting_purpose_encoding,
587 voting_purpose_default_present,
588 }),
589 })
590 })()
591 .map_err(|e| e.annotate("CIP36KeyDeregistration"))
592 }
593}
594
595impl Serialize for CIP36KeyRegistration {
596 fn serialize<'se, W: Write>(
597 &self,
598 serializer: &'se mut Serializer<W>,
599 force_canonical: bool,
600 ) -> cbor_event::Result<&'se mut Serializer<W>> {
601 let (_legacy_format, should_include_voting_purpose) = match self.delegation {
605 CIP36DelegationDistribution::Legacy { .. } => (true, false),
606 CIP36DelegationDistribution::Weighted { .. } => (
607 false,
608 self.voting_purpose != 0
609 || self
610 .encodings
611 .as_ref()
612 .map(|encs| encs.voting_purpose_default_present)
613 .unwrap_or(true),
614 ),
615 };
616 serializer.write_map_sz(
617 self.encodings
618 .as_ref()
619 .map(|encs| encs.len_encoding)
620 .unwrap_or_default()
621 .to_len_sz(
622 4 + if should_include_voting_purpose { 1 } else { 0 },
623 force_canonical,
624 ),
625 )?;
626 let deser_order = self
627 .encodings
628 .as_ref()
629 .filter(|encs| {
630 !force_canonical
631 && encs.orig_deser_order.len()
632 == 4 + if should_include_voting_purpose { 1 } else { 0 }
633 })
634 .map(|encs| encs.orig_deser_order.clone())
635 .unwrap_or_else(|| {
636 if should_include_voting_purpose {
637 vec![0, 1, 2, 3, 4]
638 } else {
639 vec![0, 1, 2, 3]
640 }
641 });
642 for field_index in deser_order {
643 match field_index {
644 0 => {
645 serializer.write_unsigned_integer_sz(
646 1u64,
647 fit_sz(
648 1u64,
649 self.encodings
650 .as_ref()
651 .map(|encs| encs.delegation_key_encoding)
652 .unwrap_or_default(),
653 force_canonical,
654 ),
655 )?;
656 self.delegation.serialize(serializer, force_canonical)?;
657 }
658 1 => {
659 serializer.write_unsigned_integer_sz(
660 2u64,
661 fit_sz(
662 2u64,
663 self.encodings
664 .as_ref()
665 .map(|encs| encs.stake_credential_key_encoding)
666 .unwrap_or_default(),
667 force_canonical,
668 ),
669 )?;
670 serializer.write_bytes_sz(
671 self.stake_credential.to_raw_bytes(),
672 self.encodings
673 .as_ref()
674 .map(|encs| encs.stake_credential_encoding.clone())
675 .unwrap_or_default()
676 .to_str_len_sz(
677 self.stake_credential.to_raw_bytes().len() as u64,
678 force_canonical,
679 ),
680 )?;
681 }
682 2 => {
683 serializer.write_unsigned_integer_sz(
684 3u64,
685 fit_sz(
686 3u64,
687 self.encodings
688 .as_ref()
689 .map(|encs| encs.address_key_encoding)
690 .unwrap_or_default(),
691 force_canonical,
692 ),
693 )?;
694 self.payment_address
695 .serialize(serializer, force_canonical)?;
696 }
697 3 => {
698 serializer.write_unsigned_integer_sz(
699 4u64,
700 fit_sz(
701 4u64,
702 self.encodings
703 .as_ref()
704 .map(|encs| encs.nonce_key_encoding)
705 .unwrap_or_default(),
706 force_canonical,
707 ),
708 )?;
709 serializer.write_unsigned_integer_sz(
710 self.nonce,
711 fit_sz(
712 self.nonce,
713 self.encodings
714 .as_ref()
715 .map(|encs| encs.nonce_encoding)
716 .unwrap_or_default(),
717 force_canonical,
718 ),
719 )?;
720 }
721 4 => {
722 if should_include_voting_purpose {
723 serializer.write_unsigned_integer_sz(
724 5u64,
725 fit_sz(
726 5u64,
727 self.encodings
728 .as_ref()
729 .map(|encs| encs.voting_purpose_key_encoding)
730 .unwrap_or_default(),
731 force_canonical,
732 ),
733 )?;
734 serializer.write_unsigned_integer_sz(
735 self.voting_purpose,
736 fit_sz(
737 self.voting_purpose,
738 self.encodings
739 .as_ref()
740 .map(|encs| encs.voting_purpose_encoding)
741 .unwrap_or_default(),
742 force_canonical,
743 ),
744 )?;
745 }
746 }
747 _ => unreachable!(),
748 };
749 }
750 self.encodings
751 .as_ref()
752 .map(|encs| encs.len_encoding)
753 .unwrap_or_default()
754 .end(serializer, force_canonical)
755 }
756}
757
758impl Deserialize for CIP36KeyRegistration {
759 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
760 let len = raw.map_sz()?;
761 let len_encoding: LenEncoding = len.into();
762 let mut read_len = CBORReadLen::new(len);
763 read_len.read_elems(4)?;
764 (|| -> Result<_, DeserializeError> {
765 let mut orig_deser_order = Vec::new();
766 let mut delegation_key_encoding = None;
767 let mut delegation = None;
768 let mut stake_credential_encoding = StringEncoding::default();
769 let mut stake_credential_key_encoding = None;
770 let mut stake_credential = None;
771 let mut address_key_encoding = None;
772 let mut payment_address = None;
773 let mut nonce_encoding = None;
774 let mut nonce_key_encoding = None;
775 let mut nonce = None;
776 let mut voting_purpose_encoding = None;
777 let mut voting_purpose_default_present = false;
778 let mut voting_purpose_key_encoding = None;
779 let mut voting_purpose = None;
780 let mut read = 0;
781 while match len {
782 cbor_event::LenSz::Len(n, _) => read < n,
783 cbor_event::LenSz::Indefinite => true,
784 } {
785 match raw.cbor_type()? {
786 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
787 (1, key_enc) => {
788 if delegation.is_some() {
789 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
790 }
791 let tmp_delegation = CIP36DelegationDistribution::deserialize(raw)
792 .map_err(|e: DeserializeError| e.annotate("delegation"))?;
793 delegation = Some(tmp_delegation);
794 delegation_key_encoding = Some(key_enc);
795 orig_deser_order.push(0);
796 }
797 (2, key_enc) => {
798 if stake_credential.is_some() {
799 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
800 }
801 let (tmp_stake_credential, tmp_stake_credential_encoding) = raw
802 .bytes_sz()
803 .map_err(Into::<DeserializeError>::into)
804 .and_then(|(bytes, enc)| {
805 PublicKey::from_raw_bytes(&bytes)
806 .map(|bytes| (bytes, StringEncoding::from(enc)))
807 .map_err(|e| {
808 DeserializeFailure::InvalidStructure(Box::new(e)).into()
809 })
810 })
811 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
812 stake_credential = Some(tmp_stake_credential);
813 stake_credential_encoding = tmp_stake_credential_encoding;
814 stake_credential_key_encoding = Some(key_enc);
815 orig_deser_order.push(1);
816 }
817 (3, key_enc) => {
818 if payment_address.is_some() {
819 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
820 }
821 let tmp_payment_address = Address::deserialize(raw)
822 .map_err(|e: DeserializeError| e.annotate("payment_address"))?;
823 payment_address = Some(tmp_payment_address);
824 address_key_encoding = Some(key_enc);
825 orig_deser_order.push(2);
826 }
827 (4, key_enc) => {
828 if nonce.is_some() {
829 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
830 }
831 let (tmp_nonce, tmp_nonce_encoding) = raw
832 .unsigned_integer_sz()
833 .map(|(x, enc)| (x, Some(enc)))
834 .map_err(Into::<DeserializeError>::into)
835 .map_err(|e: DeserializeError| e.annotate("nonce"))?;
836 nonce = Some(tmp_nonce);
837 nonce_encoding = tmp_nonce_encoding;
838 nonce_key_encoding = Some(key_enc);
839 orig_deser_order.push(3);
840 }
841 (5, key_enc) => {
842 if voting_purpose.is_some() {
843 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
844 }
845 let (tmp_voting_purpose, tmp_voting_purpose_encoding) =
846 (|| -> Result<_, DeserializeError> {
847 read_len.read_elems(1)?;
848 raw.unsigned_integer_sz()
849 .map(|(x, enc)| (x, Some(enc)))
850 .map_err(Into::<DeserializeError>::into)
851 })()
852 .map_err(|e| e.annotate("voting_purpose"))?;
853 voting_purpose = Some(tmp_voting_purpose);
854 voting_purpose_encoding = tmp_voting_purpose_encoding;
855 voting_purpose_key_encoding = Some(key_enc);
856 orig_deser_order.push(4);
857 }
858 (unknown_key, _enc) => {
859 return Err(
860 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
861 )
862 }
863 },
864 cbor_event::Type::Text => {
865 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
866 }
867 cbor_event::Type::Special => match len {
868 cbor_event::LenSz::Len(_, _) => {
869 return Err(DeserializeFailure::BreakInDefiniteLen.into())
870 }
871 cbor_event::LenSz::Indefinite => match raw.special()? {
872 cbor_event::Special::Break => break,
873 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
874 },
875 },
876 other_type => {
877 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
878 }
879 }
880 read += 1;
881 }
882 let delegation = match delegation {
883 Some(x) => x,
884 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
885 };
886 let stake_credential = match stake_credential {
887 Some(x) => x,
888 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(2)).into()),
889 };
890 let payment_address = match payment_address {
891 Some(x) => x,
892 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(3)).into()),
893 };
894 let nonce = match nonce {
895 Some(x) => x,
896 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(4)).into()),
897 };
898 if voting_purpose == Some(0) {
899 voting_purpose_default_present = true;
900 }
901 let voting_purpose = voting_purpose.unwrap_or(0);
902 read_len.finish()?;
903 Ok(Self {
904 delegation,
905 stake_credential,
906 payment_address,
907 nonce,
908 voting_purpose,
909 encodings: Some(CIP36KeyRegistrationEncoding {
910 len_encoding,
911 orig_deser_order,
912 delegation_key_encoding,
913 stake_credential_key_encoding,
914 stake_credential_encoding,
915 address_key_encoding,
916 nonce_key_encoding,
917 nonce_encoding,
918 voting_purpose_key_encoding,
919 voting_purpose_encoding,
920 voting_purpose_default_present,
921 }),
922 })
923 })()
924 .map_err(|e| e.annotate("CIP36KeyRegistration"))
925 }
926}
927
928impl Serialize for CIP36RegistrationWitness {
929 fn serialize<'se, W: Write>(
930 &self,
931 serializer: &'se mut Serializer<W>,
932 force_canonical: bool,
933 ) -> cbor_event::Result<&'se mut Serializer<W>> {
934 serializer.write_map_sz(
935 self.encodings
936 .as_ref()
937 .map(|encs| encs.len_encoding)
938 .unwrap_or_default()
939 .to_len_sz(1, force_canonical),
940 )?;
941 let deser_order = self
942 .encodings
943 .as_ref()
944 .filter(|encs| !force_canonical && encs.orig_deser_order.len() == 1)
945 .map(|encs| encs.orig_deser_order.clone())
946 .unwrap_or_else(|| vec![0]);
947 for field_index in deser_order {
948 match field_index {
949 0 => {
950 serializer.write_unsigned_integer_sz(
951 1u64,
952 fit_sz(
953 1u64,
954 self.encodings
955 .as_ref()
956 .map(|encs| encs.stake_witness_key_encoding)
957 .unwrap_or_default(),
958 force_canonical,
959 ),
960 )?;
961 serializer.write_bytes_sz(
962 self.stake_witness.to_raw_bytes(),
963 self.encodings
964 .as_ref()
965 .map(|encs| encs.stake_witness_encoding.clone())
966 .unwrap_or_default()
967 .to_str_len_sz(
968 self.stake_witness.to_raw_bytes().len() as u64,
969 force_canonical,
970 ),
971 )?;
972 }
973 _ => unreachable!(),
974 };
975 }
976 self.encodings
977 .as_ref()
978 .map(|encs| encs.len_encoding)
979 .unwrap_or_default()
980 .end(serializer, force_canonical)
981 }
982}
983
984impl Deserialize for CIP36RegistrationWitness {
985 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
986 let len = raw.map_sz()?;
987 let len_encoding: LenEncoding = len.into();
988 let mut read_len = CBORReadLen::new(len);
989 read_len.read_elems(1)?;
990 (|| -> Result<_, DeserializeError> {
991 let mut orig_deser_order = Vec::new();
992 let mut stake_witness_encoding = StringEncoding::default();
993 let mut stake_witness_key_encoding = None;
994 let mut stake_witness = None;
995 let mut read = 0;
996 while match len {
997 cbor_event::LenSz::Len(n, _) => read < n,
998 cbor_event::LenSz::Indefinite => true,
999 } {
1000 match raw.cbor_type()? {
1001 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
1002 (1, key_enc) => {
1003 if stake_witness.is_some() {
1004 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
1005 }
1006 let (tmp_stake_witness, tmp_stake_witness_encoding) = raw
1007 .bytes_sz()
1008 .map_err(Into::<DeserializeError>::into)
1009 .and_then(|(bytes, enc)| {
1010 Ed25519Signature::from_raw_bytes(&bytes)
1011 .map(|bytes| (bytes, StringEncoding::from(enc)))
1012 .map_err(|e| {
1013 DeserializeFailure::InvalidStructure(Box::new(e)).into()
1014 })
1015 })
1016 .map_err(|e: DeserializeError| e.annotate("stake_witness"))?;
1017 stake_witness = Some(tmp_stake_witness);
1018 stake_witness_encoding = tmp_stake_witness_encoding;
1019 stake_witness_key_encoding = Some(key_enc);
1020 orig_deser_order.push(0);
1021 }
1022 (unknown_key, _enc) => {
1023 return Err(
1024 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
1025 )
1026 }
1027 },
1028 cbor_event::Type::Text => {
1029 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
1030 }
1031 cbor_event::Type::Special => match len {
1032 cbor_event::LenSz::Len(_, _) => {
1033 return Err(DeserializeFailure::BreakInDefiniteLen.into())
1034 }
1035 cbor_event::LenSz::Indefinite => match raw.special()? {
1036 cbor_event::Special::Break => break,
1037 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1038 },
1039 },
1040 other_type => {
1041 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
1042 }
1043 }
1044 read += 1;
1045 }
1046 let stake_witness = match stake_witness {
1047 Some(x) => x,
1048 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
1049 };
1050 Ok(Self {
1051 stake_witness,
1052 encodings: Some(CIP36RegistrationWitnessEncoding {
1053 len_encoding,
1054 orig_deser_order,
1055 stake_witness_key_encoding,
1056 stake_witness_encoding,
1057 }),
1058 })
1059 })()
1060 .map_err(|e| e.annotate("CIP36RegistrationWitness"))
1061 }
1062}