cardano_serialization_lib/serialization/
general.rs

1use crate::*;
2use std::io::{Seek, SeekFrom};
3use crate::serialization::utils::is_break_tag;
4use hashlink::LinkedHashMap;
5
6// This file was code-generated using an experimental CDDL to rust tool:
7// https://github.com/Emurgo/cddl-codegen
8
9impl 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                /* TODO: check finite len somewhere */
40                {
41                    ()
42                }
43                cbor_event::Len::Indefinite => match raw.special()? {
44                    CBORSpecial::Break =>
45                    /* it's ok */
46                    {
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                /* TODO: check finite len somewhere */
99                {
100                    ()
101                }
102                cbor_event::Len::Indefinite => match raw.special()? {
103                    CBORSpecial::Break =>
104                    /* it's ok */
105                    {
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                    // if it's special it can be either a bool or null. if it's null, then it's empty auxiliary data, otherwise not a valid encoding
133                    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                    // if no special symbol was detected, it must have auxiliary data
145                    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            // this branch is reached, if the 3rd argument was a bool. then it simply follows the rules for checking auxiliary data
157            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            //post alonzo output
220            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            //lagacy output
236            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
248// this is used when deserializing it on its own, but the more likely case
249// is when it's done via TransactionOutputs
250impl 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                        /* TODO: check finite len somewhere */
260                        {
261                            ()
262                        }
263                        cbor_event::Len::Indefinite => match raw.special()? {
264                            CBORSpecial::Break =>
265                            /* it's ok */
266                            {
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
282// this is used by both TransactionOutput (on its own)'s deserialize
283// but also for TransactionOutputs
284// This implementation was hand-coded since cddl-codegen doesn't support deserialization
285// with array-encoded types with optional fields, due to the complexity.
286// This is made worse as this is a plain group...
287impl 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        // there are only two cases so far where this is used:
297        // 1) on its own inside of TransactionOutput's Deserialize trait (only used if someone calls to_bytes() on it)
298        // 2) from TransactionOutput's deserialization
299        // in 1) we would encounter an array-end (or track it for definite deserialization - which we don't do right now)
300        // and in 2) we would encounter the same OR we would encounter the next TransactionOutput in the array
301        // Unfortunately, both address and data hash are bytes type, so we can't just check the type, but instead
302        // must check the length, and backtrack if that wasn't the case.
303        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                    // This is an address of the next output in sequence, which luckily is > 32 bytes so there's no confusion
311                    // Go to previous place in array then carry on
312                    raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap();
313                    None
314                }
315            },
316            // not possibly a data hash
317            Ok(_) |
318            // end of input
319            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                        //bytes string tag
444                        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                /* TODO: check finite len somewhere */
615                {
616                    ()
617                }
618                cbor_event::Len::Indefinite => match raw.special()? {
619                    CBORSpecial::Break =>
620                    /* it's ok */
621                    {
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                /* TODO: check finite len somewhere */
723                {
724                    ()
725                }
726                cbor_event::Len::Indefinite => match raw.special()? {
727                    CBORSpecial::Break =>
728                    /* it's ok */
729                    {
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                /* TODO: check finite len somewhere */
806                {
807                    ()
808                }
809                cbor_event::Len::Indefinite => match raw.special()? {
810                    CBORSpecial::Break =>
811                    /* it's ok */
812                    {
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                /* TODO: check finite len somewhere */
869                {
870                    ()
871                }
872                cbor_event::Len::Indefinite => match raw.special()? {
873                    CBORSpecial::Break =>
874                    /* it's ok */
875                    {
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                /* TODO: check finite len somewhere */
965                {
966                    ()
967                }
968                cbor_event::Len::Indefinite => match raw.special()? {
969                    CBORSpecial::Break =>
970                    /* it's ok */
971                    {
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                /* TODO: check finite len somewhere */
1097                {
1098                    ()
1099                }
1100                cbor_event::Len::Indefinite => match raw.special()? {
1101                    CBORSpecial::Break =>
1102                    /* it's ok */
1103                    {
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                /* TODO: check finite len somewhere */
1272                {
1273                    ()
1274                }
1275                cbor_event::Len::Indefinite => match raw.special()? {
1276                    CBORSpecial::Break =>
1277                    /* it's ok */
1278                    {
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}