1use crate::*;
2use std::io::{Seek, SeekFrom};
3use crate::serialization::utils::is_break_tag;
4use hashlink::LinkedHashMap;
5
6impl cbor_event::se::Serialize for UnitInterval {
10 fn serialize<'se, W: Write>(
11 &self,
12 serializer: &'se mut Serializer<W>,
13 ) -> cbor_event::Result<&'se mut Serializer<W>> {
14 serializer.write_tag(30u64)?;
15 serializer.write_array(cbor_event::Len::Len(2))?;
16 self.numerator.serialize(serializer)?;
17 self.denominator.serialize(serializer)?;
18 Ok(serializer)
19 }
20}
21
22impl Deserialize for UnitInterval {
23 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
24 (|| -> Result<_, DeserializeError> {
25 let tag = raw.tag()?;
26 if tag != 30 {
27 return Err(DeserializeError::new(
28 "UnitInterval",
29 DeserializeFailure::TagMismatch {
30 found: tag,
31 expected: 30,
32 },
33 ));
34 }
35 let len = raw.array()?;
36 let ret = Self::deserialize_as_embedded_group(raw, len);
37 match len {
38 cbor_event::Len::Len(_) =>
39 {
41 ()
42 }
43 cbor_event::Len::Indefinite => match raw.special()? {
44 CBORSpecial::Break =>
45 {
47 ()
48 }
49 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
50 },
51 }
52 ret
53 })()
54 .map_err(|e| e.annotate("UnitInterval"))
55 }
56}
57
58impl DeserializeEmbeddedGroup for UnitInterval {
59 fn deserialize_as_embedded_group<R: BufRead + Seek>(
60 raw: &mut Deserializer<R>,
61 _: cbor_event::Len,
62 ) -> Result<Self, DeserializeError> {
63 let numerator = (|| -> Result<_, DeserializeError> { Ok(BigNum::deserialize(raw)?) })()
64 .map_err(|e| e.annotate("numerator"))?;
65 let denominator = (|| -> Result<_, DeserializeError> { Ok(BigNum::deserialize(raw)?) })()
66 .map_err(|e| e.annotate("denominator"))?;
67 Ok(UnitInterval {
68 numerator,
69 denominator,
70 })
71 }
72}
73
74impl cbor_event::se::Serialize for Transaction {
75 fn serialize<'se, W: Write>(
76 &self,
77 serializer: &'se mut Serializer<W>,
78 ) -> cbor_event::Result<&'se mut Serializer<W>> {
79 serializer.write_array(cbor_event::Len::Len(4))?;
80 self.body.serialize(serializer)?;
81 self.witness_set.serialize(serializer)?;
82 serializer.write_special(CBORSpecial::Bool(self.is_valid))?;
83 match &self.auxiliary_data {
84 Some(x) => x.serialize(serializer),
85 None => serializer.write_special(CBORSpecial::Null),
86 }?;
87 Ok(serializer)
88 }
89}
90
91impl Deserialize for Transaction {
92 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
93 (|| -> Result<_, DeserializeError> {
94 let len = raw.array()?;
95 let ret = Self::deserialize_as_embedded_group(raw, len);
96 match len {
97 cbor_event::Len::Len(_) =>
98 {
100 ()
101 }
102 cbor_event::Len::Indefinite => match raw.special()? {
103 CBORSpecial::Break =>
104 {
106 ()
107 }
108 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
109 },
110 }
111 ret
112 })()
113 .map_err(|e| e.annotate("Transaction"))
114 }
115}
116
117impl DeserializeEmbeddedGroup for Transaction {
118 fn deserialize_as_embedded_group<R: BufRead + Seek>(
119 raw: &mut Deserializer<R>,
120 _: cbor_event::Len,
121 ) -> Result<Self, DeserializeError> {
122 let body = (|| -> Result<_, DeserializeError> { Ok(TransactionBody::deserialize(raw)?) })()
123 .map_err(|e| e.annotate("body"))?;
124 let witness_set =
125 (|| -> Result<_, DeserializeError> { Ok(TransactionWitnessSet::deserialize(raw)?) })()
126 .map_err(|e| e.annotate("witness_set"))?;
127 let mut checked_auxiliary_data = false;
128 let mut auxiliary_data = None;
129 let is_valid = (|| -> Result<_, DeserializeError> {
130 match raw.cbor_type()? == CBORType::Special {
131 true => {
132 let special = raw.special()?;
134 if let CBORSpecial::Bool(b) = special {
135 return Ok(b);
136 } else if special == CBORSpecial::Null {
137 checked_auxiliary_data = true;
138 return Ok(true);
139 } else {
140 return Err(DeserializeFailure::ExpectedBool.into());
141 }
142 }
143 false => {
144 auxiliary_data = (|| -> Result<_, DeserializeError> {
146 Ok(Some(AuxiliaryData::deserialize(raw)?))
147 })()
148 .map_err(|e| e.annotate("auxiliary_data"))?;
149 checked_auxiliary_data = true;
150 return Ok(true);
151 }
152 }
153 })()
154 .map_err(|e| e.annotate("is_valid"))?;
155 if !checked_auxiliary_data {
156 auxiliary_data = (|| -> Result<_, DeserializeError> {
158 Ok(match raw.cbor_type()? != CBORType::Special {
159 true => Some(AuxiliaryData::deserialize(raw)?),
160 false => {
161 if raw.special()? != CBORSpecial::Null {
162 return Err(DeserializeFailure::ExpectedNull.into());
163 }
164 None
165 }
166 })
167 })()
168 .map_err(|e| e.annotate("auxiliary_data"))?;
169 }
170 Ok(Transaction {
171 body,
172 witness_set,
173 is_valid,
174 auxiliary_data,
175 })
176 }
177}
178
179impl cbor_event::se::Serialize for TransactionOutputs {
180 fn serialize<'se, W: Write>(
181 &self,
182 serializer: &'se mut Serializer<W>,
183 ) -> cbor_event::Result<&'se mut Serializer<W>> {
184 serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
185 for element in &self.0 {
186 element.serialize(serializer)?;
187 }
188 Ok(serializer)
189 }
190}
191
192impl Deserialize for TransactionOutputs {
193 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
194 let mut arr = Vec::new();
195 (|| -> Result<_, DeserializeError> {
196 let len = raw.array()?;
197 while match len {
198 cbor_event::Len::Len(n) => arr.len() < n as usize,
199 cbor_event::Len::Indefinite => true,
200 } {
201 if is_break_tag(raw, "TransactionOutputs")? {
202 break;
203 }
204 arr.push(TransactionOutput::deserialize(raw)?);
205 }
206 Ok(())
207 })()
208 .map_err(|e| e.annotate("TransactionOutputs"))?;
209 Ok(Self(arr))
210 }
211}
212
213impl cbor_event::se::Serialize for TransactionOutput {
214 fn serialize<'se, W: Write>(
215 &self,
216 serializer: &'se mut Serializer<W>,
217 ) -> cbor_event::Result<&'se mut Serializer<W>> {
218 if self.has_plutus_data() || self.has_script_ref() {
219 let map_len = 2 + opt64(&self.plutus_data) + opt64(&self.script_ref);
221 serializer.write_map(cbor_event::Len::Len(map_len))?;
222 serializer.write_unsigned_integer(0)?;
223 self.address.serialize(serializer)?;
224 serializer.write_unsigned_integer(1)?;
225 self.amount.serialize(serializer)?;
226 if let Some(field) = &self.plutus_data {
227 serializer.write_unsigned_integer(2)?;
228 field.serialize(serializer)?;
229 }
230 if let Some(field) = &self.script_ref {
231 serializer.write_unsigned_integer(3)?;
232 field.serialize(serializer)?;
233 }
234 } else {
235 let data_hash = &self.data_hash();
237 serializer.write_array(cbor_event::Len::Len(2 + opt64(&data_hash)))?;
238 self.address.serialize(serializer)?;
239 self.amount.serialize(serializer)?;
240 if let Some(pure_data_hash) = data_hash {
241 pure_data_hash.serialize(serializer)?;
242 }
243 }
244 Ok(serializer)
245 }
246}
247
248impl Deserialize for TransactionOutput {
251 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
252 (|| -> Result<_, DeserializeError> {
253 match raw.cbor_type()? {
254 CBORType::Array => {
255 let len = raw.array()?;
256 let ret = Self::deserialize_as_embedded_group(raw, len);
257 match len {
258 cbor_event::Len::Len(_) =>
259 {
261 ()
262 }
263 cbor_event::Len::Indefinite => match raw.special()? {
264 CBORSpecial::Break =>
265 {
267 ()
268 }
269 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
270 },
271 }
272 ret
273 }
274 CBORType::Map => deserialize_as_postalonzo_output(raw),
275 cbor_type => Err(DeserializeFailure::UnexpectedKeyType(cbor_type).into()),
276 }
277 })()
278 .map_err(|e| e.annotate("TransactionOutput"))
279 }
280}
281
282impl DeserializeEmbeddedGroup for TransactionOutput {
288 fn deserialize_as_embedded_group<R: BufRead + Seek>(
289 raw: &mut Deserializer<R>,
290 _: cbor_event::Len,
291 ) -> Result<Self, DeserializeError> {
292 let address = (|| -> Result<_, DeserializeError> { Ok(Address::deserialize(raw)?) })()
293 .map_err(|e| e.annotate("address"))?;
294 let amount = (|| -> Result<_, DeserializeError> { Ok(Value::deserialize(raw)?) })()
295 .map_err(|e| e.annotate("amount"))?;
296 let data_hash = match raw.cbor_type() {
304 Ok(cbor_event::Type::Bytes) => {
305 let initial_position = raw.as_mut_ref().seek(SeekFrom::Current(0)).unwrap();
306 let bytes = raw.bytes().unwrap();
307 if bytes.len() == DataHash::BYTE_COUNT {
308 Some(DataOption::DataHash(DataHash(bytes[..DataHash::BYTE_COUNT].try_into().unwrap())))
309 } else {
310 raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap();
313 None
314 }
315 },
316 Ok(_) |
318 Err(_) => None,
320 };
321 Ok(TransactionOutput {
322 address,
323 amount,
324 plutus_data: data_hash,
325 script_ref: None,
326 serialization_format: Some(CborContainerType::Array),
327 })
328 }
329}
330
331fn deserialize_as_postalonzo_output<R: BufRead + Seek>(
332 raw: &mut Deserializer<R>,
333) -> Result<TransactionOutput, DeserializeError> {
334 (|| -> Result<_, DeserializeError> {
335 let len = raw.map()?;
336 let mut read_len = CBORReadLen::new(len);
337 let mut address = None;
338 let mut amount = None;
339 let mut data = None;
340 let mut script_ref = None;
341 let mut read = 0;
342 while match len {
343 cbor_event::Len::Len(n) => read < n as usize,
344 cbor_event::Len::Indefinite => true,
345 } {
346 match raw.cbor_type()? {
347 CBORType::UnsignedInteger => match raw.unsigned_integer()? {
348 0 => {
349 if address.is_some() {
350 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
351 }
352 address = Some(
353 (|| -> Result<_, DeserializeError> {
354 read_len.read_elems(1)?;
355 Ok(Address::deserialize(raw)?)
356 })()
357 .map_err(|e| e.annotate("address"))?,
358 );
359 }
360 1 => {
361 if amount.is_some() {
362 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
363 }
364 amount = Some(
365 (|| -> Result<_, DeserializeError> {
366 read_len.read_elems(1)?;
367 Ok(Value::deserialize(raw)?)
368 })()
369 .map_err(|e| e.annotate("amount"))?,
370 );
371 }
372 2 => {
373 if data.is_some() {
374 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
375 }
376 data = Some(
377 (|| -> Result<_, DeserializeError> {
378 read_len.read_elems(1)?;
379 Ok(DataOption::deserialize(raw)?)
380 })()
381 .map_err(|e| e.annotate("data"))?,
382 );
383 }
384 3 => {
385 if script_ref.is_some() {
386 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
387 }
388 script_ref = Some(
389 (|| -> Result<_, DeserializeError> {
390 read_len.read_elems(1)?;
391 Ok(ScriptRef::deserialize(raw)?)
392 })()
393 .map_err(|e| e.annotate("script_ref"))?,
394 );
395 }
396 unknown_key => {
397 return Err(DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into())
398 }
399 },
400 other_type => return Err(DeserializeFailure::UnexpectedKeyType(other_type).into()),
401 }
402 read += 1;
403 }
404 let address = match address {
405 Some(x) => x,
406 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(0)).into()),
407 };
408 let amount = match amount {
409 Some(x) => x,
410 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
411 };
412
413 read_len.finish()?;
414 Ok(TransactionOutput {
415 address,
416 amount,
417 plutus_data: data,
418 script_ref,
419 serialization_format: Some(CborContainerType::Map),
420 })
421 })()
422 .map_err(|e| e.annotate("TransactionOutput"))
423}
424
425impl Deserialize for DataOption {
426 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
427 (|| -> Result<_, DeserializeError> {
428 let len = raw.array()?;
429 if let cbor_event::Len::Len(n) = len {
430 if n != 2 {
431 return Err(DeserializeFailure::CBOR(cbor_event::Error::WrongLen(
432 2,
433 len,
434 "[id, datum_or_hash]",
435 ))
436 .into());
437 }
438 }
439 let datum = match raw.unsigned_integer()? {
440 0 => DataOption::DataHash(DataHash::deserialize(raw)?),
441 1 => {
442 match raw.tag()? {
443 24 => {
445 let data = (|| -> Result<_, DeserializeError> {
446 Ok(from_bytes(&raw.bytes()?)?)
447 })()
448 .map_err(|e| e.annotate("PlutusData"))?;
449 DataOption::Data(data)
450 }
451 tag => {
452 return Err(DeserializeFailure::TagMismatch {
453 found: tag,
454 expected: 24,
455 }
456 .into());
457 }
458 }
459 }
460 n => {
461 return Err(DeserializeFailure::FixedValueMismatch {
462 found: Key::Uint(n),
463 expected: Key::Uint(0),
464 }
465 .into())
466 }
467 };
468 if let cbor_event::Len::Indefinite = len {
469 if raw.special()? != CBORSpecial::Break {
470 return Err(DeserializeFailure::EndingBreakMissing.into());
471 }
472 }
473 Ok(datum)
474 })()
475 .map_err(|e| e.annotate("DataOption"))
476 }
477}
478
479impl cbor_event::se::Serialize for DataOption {
480 fn serialize<'a, W: Write + Sized>(
481 &self,
482 serializer: &'a mut Serializer<W>,
483 ) -> cbor_event::Result<&'a mut Serializer<W>> {
484 serializer.write_array(cbor_event::Len::Len(2))?;
485 match &self {
486 DataOption::DataHash(data_hash) => {
487 serializer.write_unsigned_integer(0)?;
488 data_hash.serialize(serializer)?;
489 }
490 DataOption::Data(data) => {
491 serializer.write_unsigned_integer(1)?;
492 let bytes = data.to_bytes();
493 serializer.write_tag(24)?.write_bytes(&bytes)?;
494 }
495 }
496 Ok(serializer)
497 }
498}
499
500impl cbor_event::se::Serialize for Ipv4 {
501 fn serialize<'se, W: Write>(
502 &self,
503 serializer: &'se mut Serializer<W>,
504 ) -> cbor_event::Result<&'se mut Serializer<W>> {
505 serializer.write_bytes(&self.0)
506 }
507}
508
509impl Deserialize for Ipv4 {
510 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
511 Self::new_impl(raw.bytes()?)
512 }
513}
514
515impl cbor_event::se::Serialize for Ipv6 {
516 fn serialize<'se, W: Write>(
517 &self,
518 serializer: &'se mut Serializer<W>,
519 ) -> cbor_event::Result<&'se mut Serializer<W>> {
520 serializer.write_bytes(&self.0)
521 }
522}
523
524impl Deserialize for Ipv6 {
525 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
526 Self::new_impl(raw.bytes()?)
527 }
528}
529
530impl cbor_event::se::Serialize for DNSRecordAorAAAA {
531 fn serialize<'se, W: Write>(
532 &self,
533 serializer: &'se mut Serializer<W>,
534 ) -> cbor_event::Result<&'se mut Serializer<W>> {
535 serializer.write_text(&self.0)
536 }
537}
538
539impl Deserialize for DNSRecordAorAAAA {
540 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
541 Self::new_impl(raw.text()?)
542 }
543}
544
545impl cbor_event::se::Serialize for DNSRecordSRV {
546 fn serialize<'se, W: Write>(
547 &self,
548 serializer: &'se mut Serializer<W>,
549 ) -> cbor_event::Result<&'se mut Serializer<W>> {
550 serializer.write_text(&self.0)
551 }
552}
553
554impl Deserialize for DNSRecordSRV {
555 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
556 Self::new_impl(raw.text()?)
557 }
558}
559
560impl cbor_event::se::Serialize for URL {
561 fn serialize<'se, W: Write>(
562 &self,
563 serializer: &'se mut Serializer<W>,
564 ) -> cbor_event::Result<&'se mut Serializer<W>> {
565 serializer.write_text(&self.0)
566 }
567}
568
569impl Deserialize for URL {
570 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
571 Self::new_impl(raw.text()?)
572 }
573}
574
575impl cbor_event::se::Serialize for SingleHostAddr {
576 fn serialize<'se, W: Write>(
577 &self,
578 serializer: &'se mut Serializer<W>,
579 ) -> cbor_event::Result<&'se mut Serializer<W>> {
580 serializer.write_array(cbor_event::Len::Len(4))?;
581 self.serialize_as_embedded_group(serializer)
582 }
583}
584
585impl SerializeEmbeddedGroup for SingleHostAddr {
586 fn serialize_as_embedded_group<'se, W: Write>(
587 &self,
588 serializer: &'se mut Serializer<W>,
589 ) -> cbor_event::Result<&'se mut Serializer<W>> {
590 serializer.write_unsigned_integer(0u64)?;
591 match &self.port {
592 Some(x) => x.serialize(serializer),
593 None => serializer.write_special(CBORSpecial::Null),
594 }?;
595 match &self.ipv4 {
596 Some(x) => x.serialize(serializer),
597 None => serializer.write_special(CBORSpecial::Null),
598 }?;
599 match &self.ipv6 {
600 Some(x) => x.serialize(serializer),
601 None => serializer.write_special(CBORSpecial::Null),
602 }?;
603 Ok(serializer)
604 }
605}
606
607impl Deserialize for SingleHostAddr {
608 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
609 (|| -> Result<_, DeserializeError> {
610 let len = raw.array()?;
611 let ret = Self::deserialize_as_embedded_group(raw, len);
612 match len {
613 cbor_event::Len::Len(_) =>
614 {
616 ()
617 }
618 cbor_event::Len::Indefinite => match raw.special()? {
619 CBORSpecial::Break =>
620 {
622 ()
623 }
624 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
625 },
626 }
627 ret
628 })()
629 .map_err(|e| e.annotate("SingleHostAddr"))
630 }
631}
632
633impl DeserializeEmbeddedGroup for SingleHostAddr {
634 fn deserialize_as_embedded_group<R: BufRead + Seek>(
635 raw: &mut Deserializer<R>,
636 _: cbor_event::Len,
637 ) -> Result<Self, DeserializeError> {
638 (|| -> Result<_, DeserializeError> {
639 let index_0_value = raw.unsigned_integer()?;
640 if index_0_value != 0 {
641 return Err(DeserializeFailure::FixedValueMismatch {
642 found: Key::Uint(index_0_value),
643 expected: Key::Uint(0),
644 }
645 .into());
646 }
647 Ok(())
648 })()
649 .map_err(|e| e.annotate("index_0"))?;
650 let port = (|| -> Result<_, DeserializeError> {
651 Ok(match raw.cbor_type()? != CBORType::Special {
652 true => Some(Port::deserialize(raw)?),
653 false => {
654 if raw.special()? != CBORSpecial::Null {
655 return Err(DeserializeFailure::ExpectedNull.into());
656 }
657 None
658 }
659 })
660 })()
661 .map_err(|e| e.annotate("port"))?;
662 let ipv4 = (|| -> Result<_, DeserializeError> {
663 Ok(match raw.cbor_type()? != CBORType::Special {
664 true => Some(Ipv4::deserialize(raw)?),
665 false => {
666 if raw.special()? != CBORSpecial::Null {
667 return Err(DeserializeFailure::ExpectedNull.into());
668 }
669 None
670 }
671 })
672 })()
673 .map_err(|e| e.annotate("ipv4"))?;
674 let ipv6 = (|| -> Result<_, DeserializeError> {
675 Ok(match raw.cbor_type()? != CBORType::Special {
676 true => Some(Ipv6::deserialize(raw)?),
677 false => {
678 if raw.special()? != CBORSpecial::Null {
679 return Err(DeserializeFailure::ExpectedNull.into());
680 }
681 None
682 }
683 })
684 })()
685 .map_err(|e| e.annotate("ipv6"))?;
686 Ok(SingleHostAddr { port, ipv4, ipv6 })
687 }
688}
689
690impl cbor_event::se::Serialize for SingleHostName {
691 fn serialize<'se, W: Write>(
692 &self,
693 serializer: &'se mut Serializer<W>,
694 ) -> cbor_event::Result<&'se mut Serializer<W>> {
695 serializer.write_array(cbor_event::Len::Len(3))?;
696 self.serialize_as_embedded_group(serializer)
697 }
698}
699
700impl SerializeEmbeddedGroup for SingleHostName {
701 fn serialize_as_embedded_group<'se, W: Write>(
702 &self,
703 serializer: &'se mut Serializer<W>,
704 ) -> cbor_event::Result<&'se mut Serializer<W>> {
705 serializer.write_unsigned_integer(1u64)?;
706 match &self.port {
707 Some(x) => x.serialize(serializer),
708 None => serializer.write_special(CBORSpecial::Null),
709 }?;
710 self.dns_name.serialize(serializer)?;
711 Ok(serializer)
712 }
713}
714
715impl Deserialize for SingleHostName {
716 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
717 (|| -> Result<_, DeserializeError> {
718 let len = raw.array()?;
719 let ret = Self::deserialize_as_embedded_group(raw, len);
720 match len {
721 cbor_event::Len::Len(_) =>
722 {
724 ()
725 }
726 cbor_event::Len::Indefinite => match raw.special()? {
727 CBORSpecial::Break =>
728 {
730 ()
731 }
732 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
733 },
734 }
735 ret
736 })()
737 .map_err(|e| e.annotate("SingleHostName"))
738 }
739}
740
741impl DeserializeEmbeddedGroup for SingleHostName {
742 fn deserialize_as_embedded_group<R: BufRead + Seek>(
743 raw: &mut Deserializer<R>,
744 _: cbor_event::Len,
745 ) -> Result<Self, DeserializeError> {
746 (|| -> Result<_, DeserializeError> {
747 let index_0_value = raw.unsigned_integer()?;
748 if index_0_value != 1 {
749 return Err(DeserializeFailure::FixedValueMismatch {
750 found: Key::Uint(index_0_value),
751 expected: Key::Uint(1),
752 }
753 .into());
754 }
755 Ok(())
756 })()
757 .map_err(|e| e.annotate("index_0"))?;
758 let port = (|| -> Result<_, DeserializeError> {
759 Ok(match raw.cbor_type()? != CBORType::Special {
760 true => Some(Port::deserialize(raw)?),
761 false => {
762 if raw.special()? != CBORSpecial::Null {
763 return Err(DeserializeFailure::ExpectedNull.into());
764 }
765 None
766 }
767 })
768 })()
769 .map_err(|e| e.annotate("port"))?;
770 let dns_name =
771 (|| -> Result<_, DeserializeError> { Ok(DNSRecordAorAAAA::deserialize(raw)?) })()
772 .map_err(|e| e.annotate("dns_name"))?;
773 Ok(SingleHostName { port, dns_name })
774 }
775}
776
777impl cbor_event::se::Serialize for MultiHostName {
778 fn serialize<'se, W: Write>(
779 &self,
780 serializer: &'se mut Serializer<W>,
781 ) -> cbor_event::Result<&'se mut Serializer<W>> {
782 serializer.write_array(cbor_event::Len::Len(2))?;
783 self.serialize_as_embedded_group(serializer)
784 }
785}
786
787impl SerializeEmbeddedGroup for MultiHostName {
788 fn serialize_as_embedded_group<'se, W: Write>(
789 &self,
790 serializer: &'se mut Serializer<W>,
791 ) -> cbor_event::Result<&'se mut Serializer<W>> {
792 serializer.write_unsigned_integer(2u64)?;
793 self.dns_name.serialize(serializer)?;
794 Ok(serializer)
795 }
796}
797
798impl Deserialize for MultiHostName {
799 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
800 (|| -> Result<_, DeserializeError> {
801 let len = raw.array()?;
802 let ret = Self::deserialize_as_embedded_group(raw, len);
803 match len {
804 cbor_event::Len::Len(_) =>
805 {
807 ()
808 }
809 cbor_event::Len::Indefinite => match raw.special()? {
810 CBORSpecial::Break =>
811 {
813 ()
814 }
815 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
816 },
817 }
818 ret
819 })()
820 .map_err(|e| e.annotate("MultiHostName"))
821 }
822}
823
824impl DeserializeEmbeddedGroup for MultiHostName {
825 fn deserialize_as_embedded_group<R: BufRead + Seek>(
826 raw: &mut Deserializer<R>,
827 _: cbor_event::Len,
828 ) -> Result<Self, DeserializeError> {
829 (|| -> Result<_, DeserializeError> {
830 let index_0_value = raw.unsigned_integer()?;
831 if index_0_value != 2 {
832 return Err(DeserializeFailure::FixedValueMismatch {
833 found: Key::Uint(index_0_value),
834 expected: Key::Uint(2),
835 }
836 .into());
837 }
838 Ok(())
839 })()
840 .map_err(|e| e.annotate("index_0"))?;
841 let dns_name =
842 (|| -> Result<_, DeserializeError> { Ok(DNSRecordSRV::deserialize(raw)?) })()
843 .map_err(|e| e.annotate("dns_name"))?;
844 Ok(MultiHostName { dns_name })
845 }
846}
847
848impl cbor_event::se::Serialize for RelayEnum {
849 fn serialize<'se, W: Write>(
850 &self,
851 serializer: &'se mut Serializer<W>,
852 ) -> cbor_event::Result<&'se mut Serializer<W>> {
853 match self {
854 RelayEnum::SingleHostAddr(x) => x.serialize(serializer),
855 RelayEnum::SingleHostName(x) => x.serialize(serializer),
856 RelayEnum::MultiHostName(x) => x.serialize(serializer),
857 }
858 }
859}
860
861impl Deserialize for RelayEnum {
862 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
863 (|| -> Result<_, DeserializeError> {
864 let len = raw.array()?;
865 let ret = Self::deserialize_as_embedded_group(raw, len);
866 match len {
867 cbor_event::Len::Len(_) =>
868 {
870 ()
871 }
872 cbor_event::Len::Indefinite => match raw.special()? {
873 CBORSpecial::Break =>
874 {
876 ()
877 }
878 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
879 },
880 }
881 ret
882 })()
883 .map_err(|e| e.annotate("RelayEnum"))
884 }
885}
886
887impl DeserializeEmbeddedGroup for RelayEnum {
888 fn deserialize_as_embedded_group<R: BufRead + Seek>(
889 raw: &mut Deserializer<R>,
890 len: cbor_event::Len,
891 ) -> Result<Self, DeserializeError> {
892 let initial_position = raw.as_mut_ref().seek(SeekFrom::Current(0)).unwrap();
893 match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
894 Ok(SingleHostAddr::deserialize_as_embedded_group(raw, len)?)
895 })(raw)
896 {
897 Ok(variant) => return Ok(RelayEnum::SingleHostAddr(variant)),
898 Err(_) => raw
899 .as_mut_ref()
900 .seek(SeekFrom::Start(initial_position))
901 .unwrap(),
902 };
903 match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
904 Ok(SingleHostName::deserialize_as_embedded_group(raw, len)?)
905 })(raw)
906 {
907 Ok(variant) => return Ok(RelayEnum::SingleHostName(variant)),
908 Err(_) => raw
909 .as_mut_ref()
910 .seek(SeekFrom::Start(initial_position))
911 .unwrap(),
912 };
913 match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
914 Ok(MultiHostName::deserialize_as_embedded_group(raw, len)?)
915 })(raw)
916 {
917 Ok(variant) => return Ok(RelayEnum::MultiHostName(variant)),
918 Err(_) => raw
919 .as_mut_ref()
920 .seek(SeekFrom::Start(initial_position))
921 .unwrap(),
922 };
923 Err(DeserializeError::new(
924 "RelayEnum",
925 DeserializeFailure::NoVariantMatched.into(),
926 ))
927 }
928}
929
930impl cbor_event::se::Serialize for Relay {
931 fn serialize<'se, W: Write>(
932 &self,
933 serializer: &'se mut Serializer<W>,
934 ) -> cbor_event::Result<&'se mut Serializer<W>> {
935 self.0.serialize(serializer)
936 }
937}
938
939impl Deserialize for Relay {
940 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
941 Ok(Self(RelayEnum::deserialize(raw)?))
942 }
943}
944
945impl cbor_event::se::Serialize for PoolMetadata {
946 fn serialize<'se, W: Write>(
947 &self,
948 serializer: &'se mut Serializer<W>,
949 ) -> cbor_event::Result<&'se mut Serializer<W>> {
950 serializer.write_array(cbor_event::Len::Len(2))?;
951 self.url.serialize(serializer)?;
952 self.pool_metadata_hash.serialize(serializer)?;
953 Ok(serializer)
954 }
955}
956
957impl Deserialize for PoolMetadata {
958 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
959 (|| -> Result<_, DeserializeError> {
960 let len = raw.array()?;
961 let ret = Self::deserialize_as_embedded_group(raw, len);
962 match len {
963 cbor_event::Len::Len(_) =>
964 {
966 ()
967 }
968 cbor_event::Len::Indefinite => match raw.special()? {
969 CBORSpecial::Break =>
970 {
972 ()
973 }
974 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
975 },
976 }
977 ret
978 })()
979 .map_err(|e| e.annotate("PoolMetadata"))
980 }
981}
982
983impl DeserializeEmbeddedGroup for PoolMetadata {
984 fn deserialize_as_embedded_group<R: BufRead + Seek>(
985 raw: &mut Deserializer<R>,
986 _: cbor_event::Len,
987 ) -> Result<Self, DeserializeError> {
988 let url = (|| -> Result<_, DeserializeError> { Ok(URL::deserialize(raw)?) })()
989 .map_err(|e| e.annotate("url"))?;
990 let pool_metadata_hash =
991 (|| -> Result<_, DeserializeError> { Ok(PoolMetadataHash::deserialize(raw)?) })()
992 .map_err(|e| e.annotate("pool_metadata_hash"))?;
993 Ok(PoolMetadata {
994 url,
995 pool_metadata_hash,
996 })
997 }
998}
999
1000impl cbor_event::se::Serialize for RewardAddresses {
1001 fn serialize<'se, W: Write>(
1002 &self,
1003 serializer: &'se mut Serializer<W>,
1004 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1005 serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
1006 for element in &self.0 {
1007 element.serialize(serializer)?;
1008 }
1009 Ok(serializer)
1010 }
1011}
1012
1013impl Deserialize for RewardAddresses {
1014 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1015 let mut arr = Vec::new();
1016 (|| -> Result<_, DeserializeError> {
1017 let len = raw.array()?;
1018 while match len {
1019 cbor_event::Len::Len(n) => arr.len() < n as usize,
1020 cbor_event::Len::Indefinite => true,
1021 } {
1022 if is_break_tag(raw, "RewardAddresses")? {
1023 break;
1024 }
1025 arr.push(RewardAddress::deserialize(raw)?);
1026 }
1027 Ok(())
1028 })()
1029 .map_err(|e| e.annotate("RewardAddresses"))?;
1030 Ok(Self(arr))
1031 }
1032}
1033
1034impl cbor_event::se::Serialize for Withdrawals {
1035 fn serialize<'se, W: Write>(
1036 &self,
1037 serializer: &'se mut Serializer<W>,
1038 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1039 serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
1040 for (key, value) in &self.0 {
1041 key.serialize(serializer)?;
1042 value.serialize(serializer)?;
1043 }
1044 Ok(serializer)
1045 }
1046}
1047
1048impl Deserialize for Withdrawals {
1049 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1050 let mut table = LinkedHashMap::new();
1051 (|| -> Result<_, DeserializeError> {
1052 let len = raw.map()?;
1053 while match len {
1054 cbor_event::Len::Len(n) => table.len() < n as usize,
1055 cbor_event::Len::Indefinite => true,
1056 } {
1057 if is_break_tag(raw, "Withdrawals")? {
1058 break;
1059 }
1060 let key = RewardAddress::deserialize(raw)?;
1061 let value = Coin::deserialize(raw)?;
1062 if table.insert(key.clone(), value).is_some() {
1063 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1064 "some complicated/unsupported type",
1065 )))
1066 .into());
1067 }
1068 }
1069 Ok(())
1070 })()
1071 .map_err(|e| e.annotate("Withdrawals"))?;
1072 Ok(Self(table))
1073 }
1074}
1075
1076impl cbor_event::se::Serialize for Update {
1077 fn serialize<'se, W: Write>(
1078 &self,
1079 serializer: &'se mut Serializer<W>,
1080 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1081 serializer.write_array(cbor_event::Len::Len(2))?;
1082 self.proposed_protocol_parameter_updates
1083 .serialize(serializer)?;
1084 self.epoch.serialize(serializer)?;
1085 Ok(serializer)
1086 }
1087}
1088
1089impl Deserialize for Update {
1090 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1091 (|| -> Result<_, DeserializeError> {
1092 let len = raw.array()?;
1093 let ret = Self::deserialize_as_embedded_group(raw, len);
1094 match len {
1095 cbor_event::Len::Len(_) =>
1096 {
1098 ()
1099 }
1100 cbor_event::Len::Indefinite => match raw.special()? {
1101 CBORSpecial::Break =>
1102 {
1104 ()
1105 }
1106 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1107 },
1108 }
1109 ret
1110 })()
1111 .map_err(|e| e.annotate("Update"))
1112 }
1113}
1114
1115impl DeserializeEmbeddedGroup for Update {
1116 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1117 raw: &mut Deserializer<R>,
1118 _: cbor_event::Len,
1119 ) -> Result<Self, DeserializeError> {
1120 let proposed_protocol_parameter_updates = (|| -> Result<_, DeserializeError> {
1121 Ok(ProposedProtocolParameterUpdates::deserialize(raw)?)
1122 })()
1123 .map_err(|e| e.annotate("proposed_protocol_parameter_updates"))?;
1124 let epoch = (|| -> Result<_, DeserializeError> { Ok(Epoch::deserialize(raw)?) })()
1125 .map_err(|e| e.annotate("epoch"))?;
1126 Ok(Update {
1127 proposed_protocol_parameter_updates,
1128 epoch,
1129 })
1130 }
1131}
1132
1133impl cbor_event::se::Serialize for GenesisHashes {
1134 fn serialize<'se, W: Write>(
1135 &self,
1136 serializer: &'se mut Serializer<W>,
1137 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1138 serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
1139 for element in &self.0 {
1140 element.serialize(serializer)?;
1141 }
1142 Ok(serializer)
1143 }
1144}
1145
1146impl Deserialize for GenesisHashes {
1147 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1148 let mut arr = Vec::new();
1149 (|| -> Result<_, DeserializeError> {
1150 let len = raw.array()?;
1151 while match len {
1152 cbor_event::Len::Len(n) => arr.len() < n as usize,
1153 cbor_event::Len::Indefinite => true,
1154 } {
1155 if is_break_tag(raw, "GenesisHashes")? {
1156 break;
1157 }
1158 arr.push(GenesisHash::deserialize(raw)?);
1159 }
1160 Ok(())
1161 })()
1162 .map_err(|e| e.annotate("Genesishashes"))?;
1163 Ok(Self(arr))
1164 }
1165}
1166
1167impl cbor_event::se::Serialize for ScriptHashes {
1168 fn serialize<'se, W: Write>(
1169 &self,
1170 serializer: &'se mut Serializer<W>,
1171 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1172 serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
1173 for element in &self.0 {
1174 element.serialize(serializer)?;
1175 }
1176 Ok(serializer)
1177 }
1178}
1179
1180impl Deserialize for ScriptHashes {
1181 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1182 let mut arr = Vec::new();
1183 (|| -> Result<_, DeserializeError> {
1184 let len = raw.array()?;
1185 while match len {
1186 cbor_event::Len::Len(n) => arr.len() < n as usize,
1187 cbor_event::Len::Indefinite => true,
1188 } {
1189 if is_break_tag(raw, "ScriptHashes")? {
1190 break;
1191 }
1192 arr.push(ScriptHash::deserialize(raw)?);
1193 }
1194 Ok(())
1195 })()
1196 .map_err(|e| e.annotate("ScriptHashes"))?;
1197 Ok(Self(arr))
1198 }
1199}
1200
1201impl cbor_event::se::Serialize for ProposedProtocolParameterUpdates {
1202 fn serialize<'se, W: Write>(
1203 &self,
1204 serializer: &'se mut Serializer<W>,
1205 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1206 serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
1207 for (key, value) in &self.0 {
1208 key.serialize(serializer)?;
1209 value.serialize(serializer)?;
1210 }
1211 Ok(serializer)
1212 }
1213}
1214
1215impl Deserialize for ProposedProtocolParameterUpdates {
1216 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1217 let mut table = LinkedHashMap::new();
1218 (|| -> Result<_, DeserializeError> {
1219 let len = raw.map()?;
1220 while match len {
1221 cbor_event::Len::Len(n) => table.len() < n as usize,
1222 cbor_event::Len::Indefinite => true,
1223 } {
1224 if is_break_tag(raw, "ProposedProtocolParameterUpdates")? {
1225 break;
1226 }
1227 let key = GenesisHash::deserialize(raw)?;
1228 let value = ProtocolParamUpdate::deserialize(raw)?;
1229 if table.insert(key.clone(), value).is_some() {
1230 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1231 "some complicated/unsupported type",
1232 )))
1233 .into());
1234 }
1235 }
1236 Ok(())
1237 })()
1238 .map_err(|e| e.annotate("ProposedProtocolParameterUpdates"))?;
1239 Ok(Self(table))
1240 }
1241}
1242
1243impl cbor_event::se::Serialize for ProtocolVersion {
1244 fn serialize<'se, W: Write>(
1245 &self,
1246 serializer: &'se mut Serializer<W>,
1247 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1248 serializer.write_array(cbor_event::Len::Len(2))?;
1249 self.serialize_as_embedded_group(serializer)
1250 }
1251}
1252
1253impl SerializeEmbeddedGroup for ProtocolVersion {
1254 fn serialize_as_embedded_group<'se, W: Write>(
1255 &self,
1256 serializer: &'se mut Serializer<W>,
1257 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1258 self.major.serialize(serializer)?;
1259 self.minor.serialize(serializer)?;
1260 Ok(serializer)
1261 }
1262}
1263
1264impl Deserialize for ProtocolVersion {
1265 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1266 (|| -> Result<_, DeserializeError> {
1267 let len = raw.array()?;
1268 let ret = Self::deserialize_as_embedded_group(raw, len);
1269 match len {
1270 cbor_event::Len::Len(_) =>
1271 {
1273 ()
1274 }
1275 cbor_event::Len::Indefinite => match raw.special()? {
1276 CBORSpecial::Break =>
1277 {
1279 ()
1280 }
1281 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1282 },
1283 }
1284 ret
1285 })()
1286 .map_err(|e| e.annotate("ProtocolVersion"))
1287 }
1288}
1289
1290impl DeserializeEmbeddedGroup for ProtocolVersion {
1291 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1292 raw: &mut Deserializer<R>,
1293 _: cbor_event::Len,
1294 ) -> Result<Self, DeserializeError> {
1295 let major = (|| -> Result<_, DeserializeError> { Ok(u32::deserialize(raw)?) })()
1296 .map_err(|e| e.annotate("major"))?;
1297 let minor = (|| -> Result<_, DeserializeError> { Ok(u32::deserialize(raw)?) })()
1298 .map_err(|e| e.annotate("minor"))?;
1299 Ok(ProtocolVersion { major, minor })
1300 }
1301}
1302
1303impl cbor_event::se::Serialize for AuxiliaryDataSet {
1304 fn serialize<'se, W: Write>(
1305 &self,
1306 serializer: &'se mut Serializer<W>,
1307 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1308 serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
1309 for (key, value) in &self.0 {
1310 key.serialize(serializer)?;
1311 value.serialize(serializer)?;
1312 }
1313 Ok(serializer)
1314 }
1315}
1316
1317impl Deserialize for AuxiliaryDataSet {
1318 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1319 let mut table = LinkedHashMap::new();
1320 (|| -> Result<_, DeserializeError> {
1321 let len = raw.map()?;
1322 while match len {
1323 cbor_event::Len::Len(n) => table.len() < n as usize,
1324 cbor_event::Len::Indefinite => true,
1325 } {
1326 if is_break_tag(raw, "AuxiliaryDataSet")? {
1327 break;
1328 }
1329 let key = TransactionIndex::deserialize(raw)?;
1330 let value = AuxiliaryData::deserialize(raw)?;
1331 if table.insert(key.clone(), value).is_some() {
1332 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1333 "some complicated/unsupported type",
1334 )))
1335 .into());
1336 }
1337 }
1338 Ok(())
1339 })()
1340 .map_err(|e| e.annotate("AuxiliaryDataSet"))?;
1341 Ok(Self(table))
1342 }
1343}
1344
1345impl cbor_event::se::Serialize for AssetName {
1346 fn serialize<'se, W: Write>(
1347 &self,
1348 serializer: &'se mut Serializer<W>,
1349 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1350 serializer.write_bytes(&self.0)
1351 }
1352}
1353
1354impl Deserialize for AssetName {
1355 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1356 Self::new_impl(raw.bytes()?)
1357 }
1358}
1359
1360impl cbor_event::se::Serialize for AssetNames {
1361 fn serialize<'se, W: Write>(
1362 &self,
1363 serializer: &'se mut Serializer<W>,
1364 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1365 serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
1366 for element in &self.0 {
1367 element.serialize(serializer)?;
1368 }
1369 Ok(serializer)
1370 }
1371}
1372
1373impl Deserialize for AssetNames {
1374 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1375 let mut arr = Vec::new();
1376 (|| -> Result<_, DeserializeError> {
1377 let len = raw.array()?;
1378 while match len {
1379 cbor_event::Len::Len(n) => arr.len() < n as usize,
1380 cbor_event::Len::Indefinite => true,
1381 } {
1382 if is_break_tag(raw, "AssetNames")? {
1383 break;
1384 }
1385 arr.push(AssetName::deserialize(raw)?);
1386 }
1387 Ok(())
1388 })()
1389 .map_err(|e| e.annotate("AssetNames"))?;
1390 Ok(Self(arr))
1391 }
1392}
1393
1394impl cbor_event::se::Serialize for Assets {
1395 fn serialize<'se, W: Write>(
1396 &self,
1397 serializer: &'se mut Serializer<W>,
1398 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1399 serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
1400 for (key, value) in &self.0 {
1401 key.serialize(serializer)?;
1402 value.serialize(serializer)?;
1403 }
1404 Ok(serializer)
1405 }
1406}
1407
1408impl Deserialize for Assets {
1409 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1410 let mut table = std::collections::BTreeMap::new();
1411 (|| -> Result<_, DeserializeError> {
1412 let len = raw.map()?;
1413 while match len {
1414 cbor_event::Len::Len(n) => table.len() < n as usize,
1415 cbor_event::Len::Indefinite => true,
1416 } {
1417 if is_break_tag(raw, "Assets")? {
1418 break;
1419 }
1420 let key = AssetName::deserialize(raw)?;
1421 let value = BigNum::deserialize(raw)?;
1422 if table.insert(key.clone(), value).is_some() {
1423 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1424 "some complicated/unsupported type",
1425 )))
1426 .into());
1427 }
1428 }
1429 Ok(())
1430 })()
1431 .map_err(|e| e.annotate("Assets"))?;
1432 Ok(Self(table))
1433 }
1434}
1435
1436impl cbor_event::se::Serialize for MultiAsset {
1437 fn serialize<'se, W: Write>(
1438 &self,
1439 serializer: &'se mut Serializer<W>,
1440 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1441 serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
1442 for (key, value) in &self.0 {
1443 key.serialize(serializer)?;
1444 value.serialize(serializer)?;
1445 }
1446 Ok(serializer)
1447 }
1448}
1449
1450impl Deserialize for MultiAsset {
1451 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1452 let mut table = std::collections::BTreeMap::new();
1453 (|| -> Result<_, DeserializeError> {
1454 let len = raw.map()?;
1455 while match len {
1456 cbor_event::Len::Len(n) => table.len() < n as usize,
1457 cbor_event::Len::Indefinite => true,
1458 } {
1459 if is_break_tag(raw, "MultiAsset")? {
1460 break;
1461 }
1462 let key = PolicyID::deserialize(raw)?;
1463 let value = Assets::deserialize(raw)?;
1464 if table.insert(key.clone(), value).is_some() {
1465 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1466 "some complicated/unsupported type",
1467 )))
1468 .into());
1469 }
1470 }
1471 Ok(())
1472 })()
1473 .map_err(|e| e.annotate("MultiAsset"))?;
1474 Ok(Self(table))
1475 }
1476}
1477
1478impl cbor_event::se::Serialize for MintAssets {
1479 fn serialize<'se, W: Write>(
1480 &self,
1481 serializer: &'se mut Serializer<W>,
1482 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1483 serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
1484 for (key, value) in &self.0 {
1485 key.serialize(serializer)?;
1486 value.serialize(serializer)?;
1487 }
1488 Ok(serializer)
1489 }
1490}
1491
1492impl Deserialize for MintAssets {
1493 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1494 let mut table = std::collections::BTreeMap::new();
1495 (|| -> Result<_, DeserializeError> {
1496 let len = raw.map()?;
1497 while match len {
1498 cbor_event::Len::Len(n) => table.len() < n as usize,
1499 cbor_event::Len::Indefinite => true,
1500 } {
1501 if is_break_tag(raw, "MintAssets")? {
1502 break;
1503 }
1504 let key = AssetName::deserialize(raw)?;
1505 let value = Int::deserialize(raw)?;
1506 if table.insert(key.clone(), value).is_some() {
1507 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1508 "some complicated/unsupported type",
1509 )))
1510 .into());
1511 }
1512 }
1513 Ok(())
1514 })()
1515 .map_err(|e| e.annotate("MintAssets"))?;
1516 Ok(Self(table))
1517 }
1518}
1519
1520impl cbor_event::se::Serialize for Mint {
1521 fn serialize<'se, W: Write>(
1522 &self,
1523 serializer: &'se mut Serializer<W>,
1524 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1525 serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
1526 for (key, value) in &self.0 {
1527 key.serialize(serializer)?;
1528 value.serialize(serializer)?;
1529 }
1530 Ok(serializer)
1531 }
1532}
1533
1534impl Deserialize for Mint {
1535 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1536 let mut mints = Vec::new();
1537 (|| -> Result<_, DeserializeError> {
1538 let len = raw.map()?;
1539 while match len {
1540 cbor_event::Len::Len(n) => mints.len() < n as usize,
1541 cbor_event::Len::Indefinite => true,
1542 } {
1543 if is_break_tag(raw, "Mint")? {
1544 break;
1545 }
1546 let key = PolicyID::deserialize(raw)?;
1547 let value = MintAssets::deserialize(raw)?;
1548 mints.push((key.clone(), value));
1549 }
1550 Ok(())
1551 })()
1552 .map_err(|e| e.annotate("Mint"))?;
1553 Ok(Self(mints))
1554 }
1555}
1556
1557impl cbor_event::se::Serialize for NetworkId {
1558 fn serialize<'se, W: Write>(
1559 &self,
1560 serializer: &'se mut Serializer<W>,
1561 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1562 match self.0 {
1563 NetworkIdKind::Testnet => serializer.write_unsigned_integer(0u64),
1564 NetworkIdKind::Mainnet => serializer.write_unsigned_integer(1u64),
1565 }
1566 }
1567}
1568
1569impl Deserialize for NetworkId {
1570 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1571 (|| -> Result<_, DeserializeError> {
1572 match raw.unsigned_integer()? {
1573 0 => Ok(NetworkId::testnet()),
1574 1 => Ok(NetworkId::mainnet()),
1575 _ => Err(DeserializeError::new(
1576 "NetworkId",
1577 DeserializeFailure::NoVariantMatched.into(),
1578 )),
1579 }
1580 })()
1581 .map_err(|e| e.annotate("NetworkId"))
1582 }
1583}