1use super::cbor_encodings::*;
5use super::*;
6use crate::address::RewardAccount;
7use crate::governance::{GovActionId, Voter, VotingProcedure};
8use crate::plutus::Redeemers;
9use crate::{assets::AssetName, Script};
10use cbor_event;
11use cbor_event::de::Deserializer;
12use cbor_event::se::Serializer;
13use cml_core::error::*;
14use cml_core::serialization::*;
15use cml_crypto::RawBytesEncoding;
16use cml_crypto::ScriptHash;
17use std::io::{BufRead, Seek, SeekFrom, Write};
18
19impl Serialize for AlonzoFormatTxOut {
20 fn serialize<'se, W: Write>(
21 &self,
22 serializer: &'se mut Serializer<W>,
23 force_canonical: bool,
24 ) -> cbor_event::Result<&'se mut Serializer<W>> {
25 serializer.write_array_sz(
26 self.encodings
27 .as_ref()
28 .map(|encs| encs.len_encoding)
29 .unwrap_or_default()
30 .to_len_sz(
31 2 + match &self.datum_hash {
32 Some(_x) => 1,
33 None => 0,
34 },
35 force_canonical,
36 ),
37 )?;
38 self.address.serialize(serializer, force_canonical)?;
39 self.amount.serialize(serializer, force_canonical)?;
40 if let Some(field) = &self.datum_hash {
41 serializer.write_bytes_sz(
42 field.to_raw_bytes(),
43 self.encodings
44 .as_ref()
45 .map(|encs| encs.datum_hash_encoding.clone())
46 .unwrap_or_default()
47 .to_str_len_sz(field.to_raw_bytes().len() as u64, force_canonical),
48 )?;
49 }
50 self.encodings
51 .as_ref()
52 .map(|encs| encs.len_encoding)
53 .unwrap_or_default()
54 .end(serializer, force_canonical)
55 }
56}
57
58impl Deserialize for AlonzoFormatTxOut {
59 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
60 let len = raw.array_sz()?;
61 let len_encoding: LenEncoding = len.into();
62 let mut read_len = CBORReadLen::new(len);
63 read_len.read_elems(2)?;
64 (|| -> Result<_, DeserializeError> {
65 let address =
66 Address::deserialize(raw).map_err(|e: DeserializeError| e.annotate("address"))?;
67 let amount =
68 Value::deserialize(raw).map_err(|e: DeserializeError| e.annotate("amount"))?;
69 let (datum_hash, datum_hash_encoding) = if raw
70 .cbor_type()
71 .map(|ty| ty == cbor_event::Type::Bytes)
72 .unwrap_or(false)
73 {
74 (|| -> Result<_, DeserializeError> {
75 read_len.read_elems(1)?;
76 raw.bytes_sz()
77 .map_err(Into::<DeserializeError>::into)
78 .and_then(|(bytes, enc)| {
79 DatumHash::from_raw_bytes(&bytes)
80 .map(|bytes| (bytes, StringEncoding::from(enc)))
81 .map_err(|e| {
82 DeserializeFailure::InvalidStructure(Box::new(e)).into()
83 })
84 })
85 })()
86 .map_err(|e| e.annotate("datum_hash"))
87 .map(|(datum_hash, datum_hash_encoding)| (Some(datum_hash), datum_hash_encoding))
88 } else {
89 Ok((None, StringEncoding::default()))
90 }?;
91 match len {
92 cbor_event::LenSz::Len(_, _) => read_len.finish()?,
93 cbor_event::LenSz::Indefinite => match raw.special()? {
94 cbor_event::Special::Break => read_len.finish()?,
95 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
96 },
97 }
98 Ok(AlonzoFormatTxOut {
99 address,
100 amount,
101 datum_hash,
102 encodings: Some(AlonzoFormatTxOutEncoding {
103 len_encoding,
104 datum_hash_encoding,
105 }),
106 })
107 })()
108 .map_err(|e| e.annotate("AlonzoFormatTxOut"))
109 }
110}
111
112impl Serialize for ConwayFormatTxOut {
113 fn serialize<'se, W: Write>(
114 &self,
115 serializer: &'se mut Serializer<W>,
116 force_canonical: bool,
117 ) -> cbor_event::Result<&'se mut Serializer<W>> {
118 serializer.write_map_sz(
119 self.encodings
120 .as_ref()
121 .map(|encs| encs.len_encoding)
122 .unwrap_or_default()
123 .to_len_sz(
124 2 + match &self.datum_option {
125 Some(_) => 1,
126 None => 0,
127 } + match &self.script_reference {
128 Some(_) => 1,
129 None => 0,
130 },
131 force_canonical,
132 ),
133 )?;
134 let deser_order = self
135 .encodings
136 .as_ref()
137 .filter(|encs| {
138 !force_canonical
139 && encs.orig_deser_order.len()
140 == 2 + match &self.datum_option {
141 Some(_) => 1,
142 None => 0,
143 } + match &self.script_reference {
144 Some(_) => 1,
145 None => 0,
146 }
147 })
148 .map(|encs| encs.orig_deser_order.clone())
149 .unwrap_or_else(|| vec![0, 1, 2, 3]);
150 for field_index in deser_order {
151 match field_index {
152 0 => {
153 serializer.write_unsigned_integer_sz(
154 0u64,
155 fit_sz(
156 0u64,
157 self.encodings
158 .as_ref()
159 .map(|encs| encs.address_key_encoding)
160 .unwrap_or_default(),
161 force_canonical,
162 ),
163 )?;
164 self.address.serialize(serializer, force_canonical)?;
165 }
166 1 => {
167 serializer.write_unsigned_integer_sz(
168 1u64,
169 fit_sz(
170 1u64,
171 self.encodings
172 .as_ref()
173 .map(|encs| encs.amount_key_encoding)
174 .unwrap_or_default(),
175 force_canonical,
176 ),
177 )?;
178 self.amount.serialize(serializer, force_canonical)?;
179 }
180 2 => {
181 if let Some(field) = &self.datum_option {
182 serializer.write_unsigned_integer_sz(
183 2u64,
184 fit_sz(
185 2u64,
186 self.encodings
187 .as_ref()
188 .map(|encs| encs.datum_option_key_encoding)
189 .unwrap_or_default(),
190 force_canonical,
191 ),
192 )?;
193 field.serialize(serializer, force_canonical)?;
194 }
195 }
196 3 => {
197 if let Some(field) = &self.script_reference {
198 serializer.write_unsigned_integer_sz(
199 3u64,
200 fit_sz(
201 3u64,
202 self.encodings
203 .as_ref()
204 .map(|encs| encs.script_reference_key_encoding)
205 .unwrap_or_default(),
206 force_canonical,
207 ),
208 )?;
209 serializer.write_tag_sz(
210 24u64,
211 fit_sz(
212 24u64,
213 self.encodings
214 .as_ref()
215 .map(|encs| encs.script_reference_tag_encoding)
216 .unwrap_or_default(),
217 force_canonical,
218 ),
219 )?;
220 let mut script_reference_inner_se = Serializer::new_vec();
221 field.serialize(&mut script_reference_inner_se, force_canonical)?;
222 let script_reference_bytes = script_reference_inner_se.finalize();
223 serializer.write_bytes_sz(
224 &script_reference_bytes,
225 self.encodings
226 .as_ref()
227 .map(|encs| encs.script_reference_bytes_encoding.clone())
228 .unwrap_or_default()
229 .to_str_len_sz(
230 script_reference_bytes.len() as u64,
231 force_canonical,
232 ),
233 )?;
234 }
235 }
236 _ => unreachable!(),
237 };
238 }
239 self.encodings
240 .as_ref()
241 .map(|encs| encs.len_encoding)
242 .unwrap_or_default()
243 .end(serializer, force_canonical)
244 }
245}
246
247impl Deserialize for ConwayFormatTxOut {
248 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
249 let len = raw.map_sz()?;
250 let len_encoding: LenEncoding = len.into();
251 let mut read_len = CBORReadLen::new(len);
252 read_len.read_elems(2)?;
253 (|| -> Result<_, DeserializeError> {
254 let mut orig_deser_order = Vec::new();
255 let mut address_key_encoding = None;
256 let mut address = None;
257 let mut amount_key_encoding = None;
258 let mut amount = None;
259 let mut datum_option_key_encoding = None;
260 let mut datum_option = None;
261 let mut script_reference_tag_encoding = None;
262 let mut script_reference_bytes_encoding = StringEncoding::default();
263 let mut script_reference_key_encoding = None;
264 let mut script_reference = None;
265 let mut read = 0;
266 while match len {
267 cbor_event::LenSz::Len(n, _) => read < n,
268 cbor_event::LenSz::Indefinite => true,
269 } {
270 match raw.cbor_type()? {
271 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
272 (0, key_enc) => {
273 if address.is_some() {
274 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
275 }
276 let tmp_address = Address::deserialize(raw)
277 .map_err(|e: DeserializeError| e.annotate("address"))?;
278 address = Some(tmp_address);
279 address_key_encoding = Some(key_enc);
280 orig_deser_order.push(0);
281 }
282 (1, key_enc) => {
283 if amount.is_some() {
284 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
285 }
286 let tmp_amount = Value::deserialize(raw)
287 .map_err(|e: DeserializeError| e.annotate("amount"))?;
288 amount = Some(tmp_amount);
289 amount_key_encoding = Some(key_enc);
290 orig_deser_order.push(1);
291 }
292 (2, key_enc) => {
293 if datum_option.is_some() {
294 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
295 }
296 let tmp_datum_option = (|| -> Result<_, DeserializeError> {
297 read_len.read_elems(1)?;
298 DatumOption::deserialize(raw)
299 })()
300 .map_err(|e| e.annotate("datum_option"))?;
301 datum_option = Some(tmp_datum_option);
302 datum_option_key_encoding = Some(key_enc);
303 orig_deser_order.push(2);
304 }
305 (3, key_enc) => {
306 if script_reference.is_some() {
307 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
308 }
309 let (
310 tmp_script_reference,
311 tmp_script_reference_tag_encoding,
312 tmp_script_reference_bytes_encoding,
313 ) = (|| -> Result<_, DeserializeError> {
314 read_len.read_elems(1)?;
315 match raw.tag_sz()? {
316 (24, tag_enc) => {
317 let (
318 script_reference_bytes,
319 script_reference_bytes_encoding,
320 ) = raw.bytes_sz()?;
321 let inner_de = &mut Deserializer::from(
322 std::io::Cursor::new(script_reference_bytes),
323 );
324 Ok((
325 Script::deserialize(inner_de)?,
326 Some(tag_enc),
327 StringEncoding::from(script_reference_bytes_encoding),
328 ))
329 }
330 (tag, _enc) => Err(DeserializeFailure::TagMismatch {
331 found: tag,
332 expected: 24,
333 }
334 .into()),
335 }
336 })()
337 .map_err(|e| e.annotate("script_reference"))?;
338 script_reference = Some(tmp_script_reference);
339 script_reference_tag_encoding = tmp_script_reference_tag_encoding;
340 script_reference_bytes_encoding = tmp_script_reference_bytes_encoding;
341 script_reference_key_encoding = Some(key_enc);
342 orig_deser_order.push(3);
343 }
344 (unknown_key, _enc) => {
345 return Err(
346 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
347 )
348 }
349 },
350 cbor_event::Type::Text => {
351 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
352 }
353 cbor_event::Type::Special => match len {
354 cbor_event::LenSz::Len(_, _) => {
355 return Err(DeserializeFailure::BreakInDefiniteLen.into())
356 }
357 cbor_event::LenSz::Indefinite => match raw.special()? {
358 cbor_event::Special::Break => break,
359 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
360 },
361 },
362 other_type => {
363 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
364 }
365 }
366 read += 1;
367 }
368 let address = match address {
369 Some(x) => x,
370 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(0)).into()),
371 };
372 let amount = match amount {
373 Some(x) => x,
374 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
375 };
376 read_len.finish()?;
377 Ok(Self {
378 address,
379 amount,
380 datum_option,
381 script_reference,
382 encodings: Some(ConwayFormatTxOutEncoding {
383 len_encoding,
384 orig_deser_order,
385 address_key_encoding,
386 amount_key_encoding,
387 datum_option_key_encoding,
388 script_reference_key_encoding,
389 script_reference_tag_encoding,
390 script_reference_bytes_encoding,
391 }),
392 })
393 })()
394 .map_err(|e| e.annotate("ConwayFormatTxOut"))
395 }
396}
397
398impl Serialize for DatumOption {
399 fn serialize<'se, W: Write>(
400 &self,
401 serializer: &'se mut Serializer<W>,
402 force_canonical: bool,
403 ) -> cbor_event::Result<&'se mut Serializer<W>> {
404 match self {
405 DatumOption::Hash {
406 datum_hash,
407 len_encoding,
408 tag_encoding,
409 datum_hash_encoding,
410 } => {
411 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
412 serializer.write_unsigned_integer_sz(
413 0u64,
414 fit_sz(0u64, *tag_encoding, force_canonical),
415 )?;
416 serializer.write_bytes_sz(
417 datum_hash.to_raw_bytes(),
418 datum_hash_encoding
419 .to_str_len_sz(datum_hash.to_raw_bytes().len() as u64, force_canonical),
420 )?;
421 len_encoding.end(serializer, force_canonical)?;
422 Ok(serializer)
423 }
424 DatumOption::Datum {
425 datum,
426 len_encoding,
427 tag_encoding,
428 datum_tag_encoding,
429 datum_bytes_encoding,
430 } => {
431 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
432 serializer.write_unsigned_integer_sz(
433 1u64,
434 fit_sz(1u64, *tag_encoding, force_canonical),
435 )?;
436 serializer
437 .write_tag_sz(24u64, fit_sz(24u64, *datum_tag_encoding, force_canonical))?;
438 let mut datum_inner_se = Serializer::new_vec();
439 datum.serialize(&mut datum_inner_se, force_canonical)?;
440 let datum_bytes = datum_inner_se.finalize();
441 serializer.write_bytes_sz(
442 &datum_bytes,
443 datum_bytes_encoding.to_str_len_sz(datum_bytes.len() as u64, force_canonical),
444 )?;
445 len_encoding.end(serializer, force_canonical)?;
446 Ok(serializer)
447 }
448 }
449 }
450}
451
452impl Deserialize for DatumOption {
453 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
454 (|| -> Result<_, DeserializeError> {
455 let len = raw.array_sz()?;
456 let len_encoding: LenEncoding = len.into();
457 let initial_position = raw.as_mut_ref().stream_position().unwrap();
458 let mut errs = Vec::new();
459 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
460 let mut read_len = CBORReadLen::new(len);
461 read_len.read_elems(2)?;
462 read_len.finish()?;
463 let tag_encoding = (|| -> Result<_, DeserializeError> {
464 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
465 if tag_value != 0 {
466 return Err(DeserializeFailure::FixedValueMismatch {
467 found: Key::Uint(tag_value),
468 expected: Key::Uint(0),
469 }
470 .into());
471 }
472 Ok(Some(tag_encoding))
473 })()
474 .map_err(|e| e.annotate("tag"))?;
475 let (datum_hash, datum_hash_encoding) = raw
476 .bytes_sz()
477 .map_err(Into::<DeserializeError>::into)
478 .and_then(|(bytes, enc)| {
479 DatumHash::from_raw_bytes(&bytes)
480 .map(|bytes| (bytes, StringEncoding::from(enc)))
481 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
482 })
483 .map_err(|e: DeserializeError| e.annotate("datum_hash"))?;
484 match len {
485 cbor_event::LenSz::Len(_, _) => (),
486 cbor_event::LenSz::Indefinite => match raw.special()? {
487 cbor_event::Special::Break => (),
488 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
489 },
490 }
491 Ok(Self::Hash {
492 datum_hash,
493 len_encoding,
494 tag_encoding,
495 datum_hash_encoding,
496 })
497 })(raw);
498 match variant_deser {
499 Ok(variant) => return Ok(variant),
500 Err(e) => {
501 errs.push(e.annotate("Hash"));
502 raw.as_mut_ref()
503 .seek(SeekFrom::Start(initial_position))
504 .unwrap();
505 }
506 };
507 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
508 let mut read_len = CBORReadLen::new(len);
509 read_len.read_elems(2)?;
510 read_len.finish()?;
511 let tag_encoding = (|| -> Result<_, DeserializeError> {
512 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
513 if tag_value != 1 {
514 return Err(DeserializeFailure::FixedValueMismatch {
515 found: Key::Uint(tag_value),
516 expected: Key::Uint(1),
517 }
518 .into());
519 }
520 Ok(Some(tag_encoding))
521 })()
522 .map_err(|e| e.annotate("tag"))?;
523 let (datum, datum_tag_encoding, datum_bytes_encoding) =
524 (|| -> Result<_, DeserializeError> {
525 match raw.tag_sz()? {
526 (24, tag_enc) => {
527 let (datum_bytes, datum_bytes_encoding) = raw.bytes_sz()?;
528 let inner_de =
529 &mut Deserializer::from(std::io::Cursor::new(datum_bytes));
530 Ok((
531 PlutusData::deserialize(inner_de)?,
532 Some(tag_enc),
533 StringEncoding::from(datum_bytes_encoding),
534 ))
535 }
536 (tag, _enc) => Err(DeserializeFailure::TagMismatch {
537 found: tag,
538 expected: 24,
539 }
540 .into()),
541 }
542 })()
543 .map_err(|e| e.annotate("datum"))?;
544 match len {
545 cbor_event::LenSz::Len(_, _) => (),
546 cbor_event::LenSz::Indefinite => match raw.special()? {
547 cbor_event::Special::Break => (),
548 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
549 },
550 }
551 Ok(Self::Datum {
552 datum,
553 len_encoding,
554 tag_encoding,
555 datum_tag_encoding,
556 datum_bytes_encoding,
557 })
558 })(raw);
559 match variant_deser {
560 Ok(variant) => return Ok(variant),
561 Err(e) => {
562 errs.push(e.annotate("Datum"));
563 raw.as_mut_ref()
564 .seek(SeekFrom::Start(initial_position))
565 .unwrap();
566 }
567 };
568 Err(DeserializeError::new(
569 "DatumOption",
570 DeserializeFailure::NoVariantMatchedWithCauses(errs),
571 ))
572 })()
573 .map_err(|e| e.annotate("DatumOption"))
574 }
575}
576
577impl Serialize for NativeScript {
578 fn serialize<'se, W: Write>(
579 &self,
580 serializer: &'se mut Serializer<W>,
581 force_canonical: bool,
582 ) -> cbor_event::Result<&'se mut Serializer<W>> {
583 match self {
584 NativeScript::ScriptPubkey(script_pubkey) => {
585 script_pubkey.serialize(serializer, force_canonical)
586 }
587 NativeScript::ScriptAll(script_all) => {
588 script_all.serialize(serializer, force_canonical)
589 }
590 NativeScript::ScriptAny(script_any) => {
591 script_any.serialize(serializer, force_canonical)
592 }
593 NativeScript::ScriptNOfK(script_n_of_k) => {
594 script_n_of_k.serialize(serializer, force_canonical)
595 }
596 NativeScript::ScriptInvalidBefore(script_invalid_before) => {
597 script_invalid_before.serialize(serializer, force_canonical)
598 }
599 NativeScript::ScriptInvalidHereafter(script_invalid_hereafter) => {
600 script_invalid_hereafter.serialize(serializer, force_canonical)
601 }
602 }
603 }
604}
605
606impl Deserialize for NativeScript {
607 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
608 (|| -> Result<_, DeserializeError> {
609 let len = raw.array_sz()?;
610 let initial_position = raw.as_mut_ref().stream_position().unwrap();
611 let mut errs = Vec::new();
612 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
613 let mut read_len = CBORReadLen::new(len);
614 read_len.read_elems(2)?;
615 read_len.finish()?;
616 let ret = ScriptPubkey::deserialize_as_embedded_group(raw, &mut read_len, len);
617 match len {
618 cbor_event::LenSz::Len(_, _) => (),
619 cbor_event::LenSz::Indefinite => match raw.special()? {
620 cbor_event::Special::Break => (),
621 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
622 },
623 }
624 ret
625 })(raw);
626 match deser_variant {
627 Ok(script_pubkey) => return Ok(Self::ScriptPubkey(script_pubkey)),
628 Err(e) => {
629 errs.push(e.annotate("ScriptPubkey"));
630 raw.as_mut_ref()
631 .seek(SeekFrom::Start(initial_position))
632 .unwrap();
633 }
634 };
635 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
636 let mut read_len = CBORReadLen::new(len);
637 read_len.read_elems(2)?;
638 read_len.finish()?;
639 let ret = ScriptAll::deserialize_as_embedded_group(raw, &mut read_len, len);
640 match len {
641 cbor_event::LenSz::Len(_, _) => (),
642 cbor_event::LenSz::Indefinite => match raw.special()? {
643 cbor_event::Special::Break => (),
644 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
645 },
646 }
647 ret
648 })(raw);
649 match deser_variant {
650 Ok(script_all) => return Ok(Self::ScriptAll(script_all)),
651 Err(e) => {
652 errs.push(e.annotate("ScriptAll"));
653 raw.as_mut_ref()
654 .seek(SeekFrom::Start(initial_position))
655 .unwrap();
656 }
657 };
658 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
659 let mut read_len = CBORReadLen::new(len);
660 read_len.read_elems(2)?;
661 read_len.finish()?;
662 let ret = ScriptAny::deserialize_as_embedded_group(raw, &mut read_len, len);
663 match len {
664 cbor_event::LenSz::Len(_, _) => (),
665 cbor_event::LenSz::Indefinite => match raw.special()? {
666 cbor_event::Special::Break => (),
667 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
668 },
669 }
670 ret
671 })(raw);
672 match deser_variant {
673 Ok(script_any) => return Ok(Self::ScriptAny(script_any)),
674 Err(e) => {
675 errs.push(e.annotate("ScriptAny"));
676 raw.as_mut_ref()
677 .seek(SeekFrom::Start(initial_position))
678 .unwrap();
679 }
680 };
681 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
682 let mut read_len = CBORReadLen::new(len);
683 read_len.read_elems(3)?;
684 read_len.finish()?;
685 let ret = ScriptNOfK::deserialize_as_embedded_group(raw, &mut read_len, len);
686 match len {
687 cbor_event::LenSz::Len(_, _) => (),
688 cbor_event::LenSz::Indefinite => match raw.special()? {
689 cbor_event::Special::Break => (),
690 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
691 },
692 }
693 ret
694 })(raw);
695 match deser_variant {
696 Ok(script_n_of_k) => return Ok(Self::ScriptNOfK(script_n_of_k)),
697 Err(e) => {
698 errs.push(e.annotate("ScriptNOfK"));
699 raw.as_mut_ref()
700 .seek(SeekFrom::Start(initial_position))
701 .unwrap();
702 }
703 };
704 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
705 let mut read_len = CBORReadLen::new(len);
706 read_len.read_elems(2)?;
707 read_len.finish()?;
708 let ret =
709 ScriptInvalidBefore::deserialize_as_embedded_group(raw, &mut read_len, len);
710 match len {
711 cbor_event::LenSz::Len(_, _) => (),
712 cbor_event::LenSz::Indefinite => match raw.special()? {
713 cbor_event::Special::Break => (),
714 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
715 },
716 }
717 ret
718 })(raw);
719 match deser_variant {
720 Ok(script_invalid_before) => {
721 return Ok(Self::ScriptInvalidBefore(script_invalid_before))
722 }
723 Err(e) => {
724 errs.push(e.annotate("ScriptInvalidBefore"));
725 raw.as_mut_ref()
726 .seek(SeekFrom::Start(initial_position))
727 .unwrap();
728 }
729 };
730 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
731 let mut read_len = CBORReadLen::new(len);
732 read_len.read_elems(2)?;
733 read_len.finish()?;
734 let ret =
735 ScriptInvalidHereafter::deserialize_as_embedded_group(raw, &mut read_len, len);
736 match len {
737 cbor_event::LenSz::Len(_, _) => (),
738 cbor_event::LenSz::Indefinite => match raw.special()? {
739 cbor_event::Special::Break => (),
740 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
741 },
742 }
743 ret
744 })(raw);
745 match deser_variant {
746 Ok(script_invalid_hereafter) => {
747 return Ok(Self::ScriptInvalidHereafter(script_invalid_hereafter))
748 }
749 Err(e) => {
750 errs.push(e.annotate("ScriptInvalidHereafter"));
751 raw.as_mut_ref()
752 .seek(SeekFrom::Start(initial_position))
753 .unwrap();
754 }
755 };
756 Err(DeserializeError::new(
757 "NativeScript",
758 DeserializeFailure::NoVariantMatchedWithCauses(errs),
759 ))
760 })()
761 .map_err(|e| e.annotate("NativeScript"))
762 }
763}
764
765impl Serialize for ScriptAll {
766 fn serialize<'se, W: Write>(
767 &self,
768 serializer: &'se mut Serializer<W>,
769 force_canonical: bool,
770 ) -> cbor_event::Result<&'se mut Serializer<W>> {
771 serializer.write_array_sz(
772 self.encodings
773 .as_ref()
774 .map(|encs| encs.len_encoding)
775 .unwrap_or_default()
776 .to_len_sz(2, force_canonical),
777 )?;
778 self.serialize_as_embedded_group(serializer, force_canonical)
779 }
780}
781
782impl SerializeEmbeddedGroup for ScriptAll {
783 fn serialize_as_embedded_group<'se, W: Write>(
784 &self,
785 serializer: &'se mut Serializer<W>,
786 force_canonical: bool,
787 ) -> cbor_event::Result<&'se mut Serializer<W>> {
788 serializer.write_unsigned_integer_sz(
789 1u64,
790 fit_sz(
791 1u64,
792 self.encodings
793 .as_ref()
794 .map(|encs| encs.tag_encoding)
795 .unwrap_or_default(),
796 force_canonical,
797 ),
798 )?;
799 serializer.write_array_sz(
800 self.encodings
801 .as_ref()
802 .map(|encs| encs.native_scripts_encoding)
803 .unwrap_or_default()
804 .to_len_sz(self.native_scripts.len() as u64, force_canonical),
805 )?;
806 for element in self.native_scripts.iter() {
807 element.serialize(serializer, force_canonical)?;
808 }
809 self.encodings
810 .as_ref()
811 .map(|encs| encs.native_scripts_encoding)
812 .unwrap_or_default()
813 .end(serializer, force_canonical)?;
814 self.encodings
815 .as_ref()
816 .map(|encs| encs.len_encoding)
817 .unwrap_or_default()
818 .end(serializer, force_canonical)
819 }
820}
821
822impl Deserialize for ScriptAll {
823 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
824 let len = raw.array_sz()?;
825 let mut read_len = CBORReadLen::new(len);
826 read_len.read_elems(2)?;
827 read_len.finish()?;
828 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
829 match len {
830 cbor_event::LenSz::Len(_, _) => (),
831 cbor_event::LenSz::Indefinite => match raw.special()? {
832 cbor_event::Special::Break => (),
833 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
834 },
835 }
836 ret
837 }
838}
839
840impl DeserializeEmbeddedGroup for ScriptAll {
841 fn deserialize_as_embedded_group<R: BufRead + Seek>(
842 raw: &mut Deserializer<R>,
843 _read_len: &mut CBORReadLen,
844 len: cbor_event::LenSz,
845 ) -> Result<Self, DeserializeError> {
846 let len_encoding = len.into();
847 (|| -> Result<_, DeserializeError> {
848 let tag_encoding = (|| -> Result<_, DeserializeError> {
849 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
850 if tag_value != 1 {
851 return Err(DeserializeFailure::FixedValueMismatch {
852 found: Key::Uint(tag_value),
853 expected: Key::Uint(1),
854 }
855 .into());
856 }
857 Ok(Some(tag_encoding))
858 })()
859 .map_err(|e| e.annotate("tag"))?;
860 let (native_scripts, native_scripts_encoding) = (|| -> Result<_, DeserializeError> {
861 let mut native_scripts_arr = Vec::new();
862 let len = raw.array_sz()?;
863 let native_scripts_encoding = len.into();
864 while match len {
865 cbor_event::LenSz::Len(n, _) => (native_scripts_arr.len() as u64) < n,
866 cbor_event::LenSz::Indefinite => true,
867 } {
868 if raw.cbor_type()? == cbor_event::Type::Special {
869 assert_eq!(raw.special()?, cbor_event::Special::Break);
870 break;
871 }
872 native_scripts_arr.push(NativeScript::deserialize(raw)?);
873 }
874 Ok((native_scripts_arr, native_scripts_encoding))
875 })()
876 .map_err(|e| e.annotate("native_scripts"))?;
877 Ok(ScriptAll {
878 native_scripts,
879 encodings: Some(ScriptAllEncoding {
880 len_encoding,
881 tag_encoding,
882 native_scripts_encoding,
883 }),
884 })
885 })()
886 .map_err(|e| e.annotate("ScriptAll"))
887 }
888}
889
890impl Serialize for ScriptAny {
891 fn serialize<'se, W: Write>(
892 &self,
893 serializer: &'se mut Serializer<W>,
894 force_canonical: bool,
895 ) -> cbor_event::Result<&'se mut Serializer<W>> {
896 serializer.write_array_sz(
897 self.encodings
898 .as_ref()
899 .map(|encs| encs.len_encoding)
900 .unwrap_or_default()
901 .to_len_sz(2, force_canonical),
902 )?;
903 self.serialize_as_embedded_group(serializer, force_canonical)
904 }
905}
906
907impl SerializeEmbeddedGroup for ScriptAny {
908 fn serialize_as_embedded_group<'se, W: Write>(
909 &self,
910 serializer: &'se mut Serializer<W>,
911 force_canonical: bool,
912 ) -> cbor_event::Result<&'se mut Serializer<W>> {
913 serializer.write_unsigned_integer_sz(
914 2u64,
915 fit_sz(
916 2u64,
917 self.encodings
918 .as_ref()
919 .map(|encs| encs.tag_encoding)
920 .unwrap_or_default(),
921 force_canonical,
922 ),
923 )?;
924 serializer.write_array_sz(
925 self.encodings
926 .as_ref()
927 .map(|encs| encs.native_scripts_encoding)
928 .unwrap_or_default()
929 .to_len_sz(self.native_scripts.len() as u64, force_canonical),
930 )?;
931 for element in self.native_scripts.iter() {
932 element.serialize(serializer, force_canonical)?;
933 }
934 self.encodings
935 .as_ref()
936 .map(|encs| encs.native_scripts_encoding)
937 .unwrap_or_default()
938 .end(serializer, force_canonical)?;
939 self.encodings
940 .as_ref()
941 .map(|encs| encs.len_encoding)
942 .unwrap_or_default()
943 .end(serializer, force_canonical)
944 }
945}
946
947impl Deserialize for ScriptAny {
948 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
949 let len = raw.array_sz()?;
950 let mut read_len = CBORReadLen::new(len);
951 read_len.read_elems(2)?;
952 read_len.finish()?;
953 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
954 match len {
955 cbor_event::LenSz::Len(_, _) => (),
956 cbor_event::LenSz::Indefinite => match raw.special()? {
957 cbor_event::Special::Break => (),
958 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
959 },
960 }
961 ret
962 }
963}
964
965impl DeserializeEmbeddedGroup for ScriptAny {
966 fn deserialize_as_embedded_group<R: BufRead + Seek>(
967 raw: &mut Deserializer<R>,
968 _read_len: &mut CBORReadLen,
969 len: cbor_event::LenSz,
970 ) -> Result<Self, DeserializeError> {
971 let len_encoding = len.into();
972 (|| -> Result<_, DeserializeError> {
973 let tag_encoding = (|| -> Result<_, DeserializeError> {
974 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
975 if tag_value != 2 {
976 return Err(DeserializeFailure::FixedValueMismatch {
977 found: Key::Uint(tag_value),
978 expected: Key::Uint(2),
979 }
980 .into());
981 }
982 Ok(Some(tag_encoding))
983 })()
984 .map_err(|e| e.annotate("tag"))?;
985 let (native_scripts, native_scripts_encoding) = (|| -> Result<_, DeserializeError> {
986 let mut native_scripts_arr = Vec::new();
987 let len = raw.array_sz()?;
988 let native_scripts_encoding = len.into();
989 while match len {
990 cbor_event::LenSz::Len(n, _) => (native_scripts_arr.len() as u64) < n,
991 cbor_event::LenSz::Indefinite => true,
992 } {
993 if raw.cbor_type()? == cbor_event::Type::Special {
994 assert_eq!(raw.special()?, cbor_event::Special::Break);
995 break;
996 }
997 native_scripts_arr.push(NativeScript::deserialize(raw)?);
998 }
999 Ok((native_scripts_arr, native_scripts_encoding))
1000 })()
1001 .map_err(|e| e.annotate("native_scripts"))?;
1002 Ok(ScriptAny {
1003 native_scripts,
1004 encodings: Some(ScriptAnyEncoding {
1005 len_encoding,
1006 tag_encoding,
1007 native_scripts_encoding,
1008 }),
1009 })
1010 })()
1011 .map_err(|e| e.annotate("ScriptAny"))
1012 }
1013}
1014
1015impl Serialize for ScriptInvalidBefore {
1016 fn serialize<'se, W: Write>(
1017 &self,
1018 serializer: &'se mut Serializer<W>,
1019 force_canonical: bool,
1020 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1021 serializer.write_array_sz(
1022 self.encodings
1023 .as_ref()
1024 .map(|encs| encs.len_encoding)
1025 .unwrap_or_default()
1026 .to_len_sz(2, force_canonical),
1027 )?;
1028 self.serialize_as_embedded_group(serializer, force_canonical)
1029 }
1030}
1031
1032impl SerializeEmbeddedGroup for ScriptInvalidBefore {
1033 fn serialize_as_embedded_group<'se, W: Write>(
1034 &self,
1035 serializer: &'se mut Serializer<W>,
1036 force_canonical: bool,
1037 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1038 serializer.write_unsigned_integer_sz(
1039 4u64,
1040 fit_sz(
1041 4u64,
1042 self.encodings
1043 .as_ref()
1044 .map(|encs| encs.tag_encoding)
1045 .unwrap_or_default(),
1046 force_canonical,
1047 ),
1048 )?;
1049 serializer.write_unsigned_integer_sz(
1050 self.before,
1051 fit_sz(
1052 self.before,
1053 self.encodings
1054 .as_ref()
1055 .map(|encs| encs.before_encoding)
1056 .unwrap_or_default(),
1057 force_canonical,
1058 ),
1059 )?;
1060 self.encodings
1061 .as_ref()
1062 .map(|encs| encs.len_encoding)
1063 .unwrap_or_default()
1064 .end(serializer, force_canonical)
1065 }
1066}
1067
1068impl Deserialize for ScriptInvalidBefore {
1069 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1070 let len = raw.array_sz()?;
1071 let mut read_len = CBORReadLen::new(len);
1072 read_len.read_elems(2)?;
1073 read_len.finish()?;
1074 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1075 match len {
1076 cbor_event::LenSz::Len(_, _) => (),
1077 cbor_event::LenSz::Indefinite => match raw.special()? {
1078 cbor_event::Special::Break => (),
1079 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1080 },
1081 }
1082 ret
1083 }
1084}
1085
1086impl DeserializeEmbeddedGroup for ScriptInvalidBefore {
1087 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1088 raw: &mut Deserializer<R>,
1089 _read_len: &mut CBORReadLen,
1090 len: cbor_event::LenSz,
1091 ) -> Result<Self, DeserializeError> {
1092 let len_encoding = len.into();
1093 (|| -> Result<_, DeserializeError> {
1094 let tag_encoding = (|| -> Result<_, DeserializeError> {
1095 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1096 if tag_value != 4 {
1097 return Err(DeserializeFailure::FixedValueMismatch {
1098 found: Key::Uint(tag_value),
1099 expected: Key::Uint(4),
1100 }
1101 .into());
1102 }
1103 Ok(Some(tag_encoding))
1104 })()
1105 .map_err(|e| e.annotate("tag"))?;
1106 let (before, before_encoding) = raw
1107 .unsigned_integer_sz()
1108 .map_err(Into::<DeserializeError>::into)
1109 .map(|(x, enc)| (x, Some(enc)))
1110 .map_err(|e: DeserializeError| e.annotate("before"))?;
1111 Ok(ScriptInvalidBefore {
1112 before,
1113 encodings: Some(ScriptInvalidBeforeEncoding {
1114 len_encoding,
1115 tag_encoding,
1116 before_encoding,
1117 }),
1118 })
1119 })()
1120 .map_err(|e| e.annotate("ScriptInvalidBefore"))
1121 }
1122}
1123
1124impl Serialize for ScriptInvalidHereafter {
1125 fn serialize<'se, W: Write>(
1126 &self,
1127 serializer: &'se mut Serializer<W>,
1128 force_canonical: bool,
1129 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1130 serializer.write_array_sz(
1131 self.encodings
1132 .as_ref()
1133 .map(|encs| encs.len_encoding)
1134 .unwrap_or_default()
1135 .to_len_sz(2, force_canonical),
1136 )?;
1137 self.serialize_as_embedded_group(serializer, force_canonical)
1138 }
1139}
1140
1141impl SerializeEmbeddedGroup for ScriptInvalidHereafter {
1142 fn serialize_as_embedded_group<'se, W: Write>(
1143 &self,
1144 serializer: &'se mut Serializer<W>,
1145 force_canonical: bool,
1146 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1147 serializer.write_unsigned_integer_sz(
1148 5u64,
1149 fit_sz(
1150 5u64,
1151 self.encodings
1152 .as_ref()
1153 .map(|encs| encs.tag_encoding)
1154 .unwrap_or_default(),
1155 force_canonical,
1156 ),
1157 )?;
1158 serializer.write_unsigned_integer_sz(
1159 self.after,
1160 fit_sz(
1161 self.after,
1162 self.encodings
1163 .as_ref()
1164 .map(|encs| encs.after_encoding)
1165 .unwrap_or_default(),
1166 force_canonical,
1167 ),
1168 )?;
1169 self.encodings
1170 .as_ref()
1171 .map(|encs| encs.len_encoding)
1172 .unwrap_or_default()
1173 .end(serializer, force_canonical)
1174 }
1175}
1176
1177impl Deserialize for ScriptInvalidHereafter {
1178 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1179 let len = raw.array_sz()?;
1180 let mut read_len = CBORReadLen::new(len);
1181 read_len.read_elems(2)?;
1182 read_len.finish()?;
1183 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1184 match len {
1185 cbor_event::LenSz::Len(_, _) => (),
1186 cbor_event::LenSz::Indefinite => match raw.special()? {
1187 cbor_event::Special::Break => (),
1188 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1189 },
1190 }
1191 ret
1192 }
1193}
1194
1195impl DeserializeEmbeddedGroup for ScriptInvalidHereafter {
1196 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1197 raw: &mut Deserializer<R>,
1198 _read_len: &mut CBORReadLen,
1199 len: cbor_event::LenSz,
1200 ) -> Result<Self, DeserializeError> {
1201 let len_encoding = len.into();
1202 (|| -> Result<_, DeserializeError> {
1203 let tag_encoding = (|| -> Result<_, DeserializeError> {
1204 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1205 if tag_value != 5 {
1206 return Err(DeserializeFailure::FixedValueMismatch {
1207 found: Key::Uint(tag_value),
1208 expected: Key::Uint(5),
1209 }
1210 .into());
1211 }
1212 Ok(Some(tag_encoding))
1213 })()
1214 .map_err(|e| e.annotate("tag"))?;
1215 let (after, after_encoding) = raw
1216 .unsigned_integer_sz()
1217 .map_err(Into::<DeserializeError>::into)
1218 .map(|(x, enc)| (x, Some(enc)))
1219 .map_err(|e: DeserializeError| e.annotate("after"))?;
1220 Ok(ScriptInvalidHereafter {
1221 after,
1222 encodings: Some(ScriptInvalidHereafterEncoding {
1223 len_encoding,
1224 tag_encoding,
1225 after_encoding,
1226 }),
1227 })
1228 })()
1229 .map_err(|e| e.annotate("ScriptInvalidHereafter"))
1230 }
1231}
1232
1233impl Serialize for ScriptNOfK {
1234 fn serialize<'se, W: Write>(
1235 &self,
1236 serializer: &'se mut Serializer<W>,
1237 force_canonical: bool,
1238 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1239 serializer.write_array_sz(
1240 self.encodings
1241 .as_ref()
1242 .map(|encs| encs.len_encoding)
1243 .unwrap_or_default()
1244 .to_len_sz(3, force_canonical),
1245 )?;
1246 self.serialize_as_embedded_group(serializer, force_canonical)
1247 }
1248}
1249
1250impl SerializeEmbeddedGroup for ScriptNOfK {
1251 fn serialize_as_embedded_group<'se, W: Write>(
1252 &self,
1253 serializer: &'se mut Serializer<W>,
1254 force_canonical: bool,
1255 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1256 serializer.write_unsigned_integer_sz(
1257 3u64,
1258 fit_sz(
1259 3u64,
1260 self.encodings
1261 .as_ref()
1262 .map(|encs| encs.tag_encoding)
1263 .unwrap_or_default(),
1264 force_canonical,
1265 ),
1266 )?;
1267 serializer.write_unsigned_integer_sz(
1268 self.n,
1269 fit_sz(
1270 self.n,
1271 self.encodings
1272 .as_ref()
1273 .map(|encs| encs.n_encoding)
1274 .unwrap_or_default(),
1275 force_canonical,
1276 ),
1277 )?;
1278 serializer.write_array_sz(
1279 self.encodings
1280 .as_ref()
1281 .map(|encs| encs.native_scripts_encoding)
1282 .unwrap_or_default()
1283 .to_len_sz(self.native_scripts.len() as u64, force_canonical),
1284 )?;
1285 for element in self.native_scripts.iter() {
1286 element.serialize(serializer, force_canonical)?;
1287 }
1288 self.encodings
1289 .as_ref()
1290 .map(|encs| encs.native_scripts_encoding)
1291 .unwrap_or_default()
1292 .end(serializer, force_canonical)?;
1293 self.encodings
1294 .as_ref()
1295 .map(|encs| encs.len_encoding)
1296 .unwrap_or_default()
1297 .end(serializer, force_canonical)
1298 }
1299}
1300
1301impl Deserialize for ScriptNOfK {
1302 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1303 let len = raw.array_sz()?;
1304 let mut read_len = CBORReadLen::new(len);
1305 read_len.read_elems(3)?;
1306 read_len.finish()?;
1307 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1308 match len {
1309 cbor_event::LenSz::Len(_, _) => (),
1310 cbor_event::LenSz::Indefinite => match raw.special()? {
1311 cbor_event::Special::Break => (),
1312 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1313 },
1314 }
1315 ret
1316 }
1317}
1318
1319impl DeserializeEmbeddedGroup for ScriptNOfK {
1320 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1321 raw: &mut Deserializer<R>,
1322 _read_len: &mut CBORReadLen,
1323 len: cbor_event::LenSz,
1324 ) -> Result<Self, DeserializeError> {
1325 let len_encoding = len.into();
1326 (|| -> Result<_, DeserializeError> {
1327 let tag_encoding = (|| -> Result<_, DeserializeError> {
1328 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1329 if tag_value != 3 {
1330 return Err(DeserializeFailure::FixedValueMismatch {
1331 found: Key::Uint(tag_value),
1332 expected: Key::Uint(3),
1333 }
1334 .into());
1335 }
1336 Ok(Some(tag_encoding))
1337 })()
1338 .map_err(|e| e.annotate("tag"))?;
1339 let (n, n_encoding) = raw
1340 .unsigned_integer_sz()
1341 .map_err(Into::<DeserializeError>::into)
1342 .map(|(x, enc)| (x, Some(enc)))
1343 .map_err(|e: DeserializeError| e.annotate("n"))?;
1344 let (native_scripts, native_scripts_encoding) = (|| -> Result<_, DeserializeError> {
1345 let mut native_scripts_arr = Vec::new();
1346 let len = raw.array_sz()?;
1347 let native_scripts_encoding = len.into();
1348 while match len {
1349 cbor_event::LenSz::Len(n, _) => (native_scripts_arr.len() as u64) < n,
1350 cbor_event::LenSz::Indefinite => true,
1351 } {
1352 if raw.cbor_type()? == cbor_event::Type::Special {
1353 assert_eq!(raw.special()?, cbor_event::Special::Break);
1354 break;
1355 }
1356 native_scripts_arr.push(NativeScript::deserialize(raw)?);
1357 }
1358 Ok((native_scripts_arr, native_scripts_encoding))
1359 })()
1360 .map_err(|e| e.annotate("native_scripts"))?;
1361 Ok(ScriptNOfK {
1362 n,
1363 native_scripts,
1364 encodings: Some(ScriptNOfKEncoding {
1365 len_encoding,
1366 tag_encoding,
1367 n_encoding,
1368 native_scripts_encoding,
1369 }),
1370 })
1371 })()
1372 .map_err(|e| e.annotate("ScriptNOfK"))
1373 }
1374}
1375
1376impl Serialize for ScriptPubkey {
1377 fn serialize<'se, W: Write>(
1378 &self,
1379 serializer: &'se mut Serializer<W>,
1380 force_canonical: bool,
1381 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1382 serializer.write_array_sz(
1383 self.encodings
1384 .as_ref()
1385 .map(|encs| encs.len_encoding)
1386 .unwrap_or_default()
1387 .to_len_sz(2, force_canonical),
1388 )?;
1389 self.serialize_as_embedded_group(serializer, force_canonical)
1390 }
1391}
1392
1393impl SerializeEmbeddedGroup for ScriptPubkey {
1394 fn serialize_as_embedded_group<'se, W: Write>(
1395 &self,
1396 serializer: &'se mut Serializer<W>,
1397 force_canonical: bool,
1398 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1399 serializer.write_unsigned_integer_sz(
1400 0u64,
1401 fit_sz(
1402 0u64,
1403 self.encodings
1404 .as_ref()
1405 .map(|encs| encs.tag_encoding)
1406 .unwrap_or_default(),
1407 force_canonical,
1408 ),
1409 )?;
1410 serializer.write_bytes_sz(
1411 self.ed25519_key_hash.to_raw_bytes(),
1412 self.encodings
1413 .as_ref()
1414 .map(|encs| encs.ed25519_key_hash_encoding.clone())
1415 .unwrap_or_default()
1416 .to_str_len_sz(
1417 self.ed25519_key_hash.to_raw_bytes().len() as u64,
1418 force_canonical,
1419 ),
1420 )?;
1421 self.encodings
1422 .as_ref()
1423 .map(|encs| encs.len_encoding)
1424 .unwrap_or_default()
1425 .end(serializer, force_canonical)
1426 }
1427}
1428
1429impl Deserialize for ScriptPubkey {
1430 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1431 let len = raw.array_sz()?;
1432 let mut read_len = CBORReadLen::new(len);
1433 read_len.read_elems(2)?;
1434 read_len.finish()?;
1435 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1436 match len {
1437 cbor_event::LenSz::Len(_, _) => (),
1438 cbor_event::LenSz::Indefinite => match raw.special()? {
1439 cbor_event::Special::Break => (),
1440 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1441 },
1442 }
1443 ret
1444 }
1445}
1446
1447impl DeserializeEmbeddedGroup for ScriptPubkey {
1448 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1449 raw: &mut Deserializer<R>,
1450 _read_len: &mut CBORReadLen,
1451 len: cbor_event::LenSz,
1452 ) -> Result<Self, DeserializeError> {
1453 let len_encoding = len.into();
1454 (|| -> Result<_, DeserializeError> {
1455 let tag_encoding = (|| -> Result<_, DeserializeError> {
1456 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1457 if tag_value != 0 {
1458 return Err(DeserializeFailure::FixedValueMismatch {
1459 found: Key::Uint(tag_value),
1460 expected: Key::Uint(0),
1461 }
1462 .into());
1463 }
1464 Ok(Some(tag_encoding))
1465 })()
1466 .map_err(|e| e.annotate("tag"))?;
1467 let (ed25519_key_hash, ed25519_key_hash_encoding) = raw
1468 .bytes_sz()
1469 .map_err(Into::<DeserializeError>::into)
1470 .and_then(|(bytes, enc)| {
1471 Ed25519KeyHash::from_raw_bytes(&bytes)
1472 .map(|bytes| (bytes, StringEncoding::from(enc)))
1473 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1474 })
1475 .map_err(|e: DeserializeError| e.annotate("ed25519_key_hash"))?;
1476 Ok(ScriptPubkey {
1477 ed25519_key_hash,
1478 encodings: Some(ScriptPubkeyEncoding {
1479 len_encoding,
1480 tag_encoding,
1481 ed25519_key_hash_encoding,
1482 }),
1483 })
1484 })()
1485 .map_err(|e| e.annotate("ScriptPubkey"))
1486 }
1487}
1488
1489impl Serialize for Transaction {
1490 fn serialize<'se, W: Write>(
1491 &self,
1492 serializer: &'se mut Serializer<W>,
1493 force_canonical: bool,
1494 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1495 serializer.write_array_sz(
1496 self.encodings
1497 .as_ref()
1498 .map(|encs| encs.len_encoding)
1499 .unwrap_or_default()
1500 .to_len_sz(4, force_canonical),
1501 )?;
1502 self.body.serialize(serializer, force_canonical)?;
1503 self.witness_set.serialize(serializer, force_canonical)?;
1504 serializer.write_special(cbor_event::Special::Bool(self.is_valid))?;
1505 match &self.auxiliary_data {
1506 Some(x) => x.serialize(serializer, force_canonical),
1507 None => serializer.write_special(cbor_event::Special::Null),
1508 }?;
1509 self.encodings
1510 .as_ref()
1511 .map(|encs| encs.len_encoding)
1512 .unwrap_or_default()
1513 .end(serializer, force_canonical)
1514 }
1515}
1516
1517impl Deserialize for Transaction {
1518 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1519 let len = raw.array_sz()?;
1520 let len_encoding: LenEncoding = len.into();
1521 let mut read_len = CBORReadLen::new(len);
1522 read_len.read_elems(4)?;
1523 read_len.finish()?;
1524 (|| -> Result<_, DeserializeError> {
1525 let body = TransactionBody::deserialize(raw)
1526 .map_err(|e: DeserializeError| e.annotate("body"))?;
1527 let witness_set = TransactionWitnessSet::deserialize(raw)
1528 .map_err(|e: DeserializeError| e.annotate("witness_set"))?;
1529 let is_valid = raw
1530 .bool()
1531 .map_err(Into::into)
1532 .map_err(|e: DeserializeError| e.annotate("is_valid"))?;
1533 let auxiliary_data = (|| -> Result<_, DeserializeError> {
1534 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
1535 true => Some(AuxiliaryData::deserialize(raw)?),
1536 false => {
1537 if raw.special()? != cbor_event::Special::Null {
1538 return Err(DeserializeFailure::ExpectedNull.into());
1539 }
1540 None
1541 }
1542 })
1543 })()
1544 .map_err(|e| e.annotate("auxiliary_data"))?;
1545 match len {
1546 cbor_event::LenSz::Len(_, _) => (),
1547 cbor_event::LenSz::Indefinite => match raw.special()? {
1548 cbor_event::Special::Break => (),
1549 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1550 },
1551 }
1552 Ok(Transaction {
1553 body,
1554 witness_set,
1555 is_valid,
1556 auxiliary_data,
1557 encodings: Some(TransactionEncoding { len_encoding }),
1558 })
1559 })()
1560 .map_err(|e| e.annotate("Transaction"))
1561 }
1562}
1563
1564impl Serialize for TransactionBody {
1565 fn serialize<'se, W: Write>(
1566 &self,
1567 serializer: &'se mut Serializer<W>,
1568 force_canonical: bool,
1569 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1570 serializer.write_map_sz(
1571 self.encodings
1572 .as_ref()
1573 .map(|encs| encs.len_encoding)
1574 .unwrap_or_default()
1575 .to_len_sz(
1576 3 + match &self.ttl {
1577 Some(_) => 1,
1578 None => 0,
1579 } + match &self.certs {
1580 Some(_) => 1,
1581 None => 0,
1582 } + match &self.withdrawals {
1583 Some(_) => 1,
1584 None => 0,
1585 } + match &self.auxiliary_data_hash {
1586 Some(_) => 1,
1587 None => 0,
1588 } + match &self.validity_interval_start {
1589 Some(_) => 1,
1590 None => 0,
1591 } + match &self.mint {
1592 Some(_) => 1,
1593 None => 0,
1594 } + match &self.script_data_hash {
1595 Some(_) => 1,
1596 None => 0,
1597 } + match &self.collateral_inputs {
1598 Some(_) => 1,
1599 None => 0,
1600 } + match &self.required_signers {
1601 Some(_) => 1,
1602 None => 0,
1603 } + match &self.network_id {
1604 Some(_) => 1,
1605 None => 0,
1606 } + match &self.collateral_return {
1607 Some(_) => 1,
1608 None => 0,
1609 } + match &self.total_collateral {
1610 Some(_) => 1,
1611 None => 0,
1612 } + match &self.reference_inputs {
1613 Some(_) => 1,
1614 None => 0,
1615 } + match &self.voting_procedures {
1616 Some(_) => 1,
1617 None => 0,
1618 } + match &self.proposal_procedures {
1619 Some(_) => 1,
1620 None => 0,
1621 } + match &self.current_treasury_value {
1622 Some(_) => 1,
1623 None => 0,
1624 } + match &self.donation {
1625 Some(_) => 1,
1626 None => 0,
1627 },
1628 force_canonical,
1629 ),
1630 )?;
1631 let deser_order = self
1632 .encodings
1633 .as_ref()
1634 .filter(|encs| {
1635 !force_canonical
1636 && encs.orig_deser_order.len()
1637 == 3 + match &self.ttl {
1638 Some(_) => 1,
1639 None => 0,
1640 } + match &self.certs {
1641 Some(_) => 1,
1642 None => 0,
1643 } + match &self.withdrawals {
1644 Some(_) => 1,
1645 None => 0,
1646 } + match &self.auxiliary_data_hash {
1647 Some(_) => 1,
1648 None => 0,
1649 } + match &self.validity_interval_start {
1650 Some(_) => 1,
1651 None => 0,
1652 } + match &self.mint {
1653 Some(_) => 1,
1654 None => 0,
1655 } + match &self.script_data_hash {
1656 Some(_) => 1,
1657 None => 0,
1658 } + match &self.collateral_inputs {
1659 Some(_) => 1,
1660 None => 0,
1661 } + match &self.required_signers {
1662 Some(_) => 1,
1663 None => 0,
1664 } + match &self.network_id {
1665 Some(_) => 1,
1666 None => 0,
1667 } + match &self.collateral_return {
1668 Some(_) => 1,
1669 None => 0,
1670 } + match &self.total_collateral {
1671 Some(_) => 1,
1672 None => 0,
1673 } + match &self.reference_inputs {
1674 Some(_) => 1,
1675 None => 0,
1676 } + match &self.voting_procedures {
1677 Some(_) => 1,
1678 None => 0,
1679 } + match &self.proposal_procedures {
1680 Some(_) => 1,
1681 None => 0,
1682 } + match &self.current_treasury_value {
1683 Some(_) => 1,
1684 None => 0,
1685 } + match &self.donation {
1686 Some(_) => 1,
1687 None => 0,
1688 }
1689 })
1690 .map(|encs| encs.orig_deser_order.clone())
1691 .unwrap_or_else(|| {
1692 vec![
1693 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1694 ]
1695 });
1696 for field_index in deser_order {
1697 match field_index {
1698 0 => {
1699 serializer.write_unsigned_integer_sz(
1700 0u64,
1701 fit_sz(
1702 0u64,
1703 self.encodings
1704 .as_ref()
1705 .map(|encs| encs.inputs_key_encoding)
1706 .unwrap_or_default(),
1707 force_canonical,
1708 ),
1709 )?;
1710 self.inputs.serialize(serializer, force_canonical)?;
1711 }
1712 1 => {
1713 serializer.write_unsigned_integer_sz(
1714 1u64,
1715 fit_sz(
1716 1u64,
1717 self.encodings
1718 .as_ref()
1719 .map(|encs| encs.outputs_key_encoding)
1720 .unwrap_or_default(),
1721 force_canonical,
1722 ),
1723 )?;
1724 serializer.write_array_sz(
1725 self.encodings
1726 .as_ref()
1727 .map(|encs| encs.outputs_encoding)
1728 .unwrap_or_default()
1729 .to_len_sz(self.outputs.len() as u64, force_canonical),
1730 )?;
1731 for element in self.outputs.iter() {
1732 element.serialize(serializer, force_canonical)?;
1733 }
1734 self.encodings
1735 .as_ref()
1736 .map(|encs| encs.outputs_encoding)
1737 .unwrap_or_default()
1738 .end(serializer, force_canonical)?;
1739 }
1740 2 => {
1741 serializer.write_unsigned_integer_sz(
1742 2u64,
1743 fit_sz(
1744 2u64,
1745 self.encodings
1746 .as_ref()
1747 .map(|encs| encs.fee_key_encoding)
1748 .unwrap_or_default(),
1749 force_canonical,
1750 ),
1751 )?;
1752 serializer.write_unsigned_integer_sz(
1753 self.fee,
1754 fit_sz(
1755 self.fee,
1756 self.encodings
1757 .as_ref()
1758 .map(|encs| encs.fee_encoding)
1759 .unwrap_or_default(),
1760 force_canonical,
1761 ),
1762 )?;
1763 }
1764 3 => {
1765 if let Some(field) = &self.ttl {
1766 serializer.write_unsigned_integer_sz(
1767 3u64,
1768 fit_sz(
1769 3u64,
1770 self.encodings
1771 .as_ref()
1772 .map(|encs| encs.ttl_key_encoding)
1773 .unwrap_or_default(),
1774 force_canonical,
1775 ),
1776 )?;
1777 serializer.write_unsigned_integer_sz(
1778 *field,
1779 fit_sz(
1780 *field,
1781 self.encodings
1782 .as_ref()
1783 .map(|encs| encs.ttl_encoding)
1784 .unwrap_or_default(),
1785 force_canonical,
1786 ),
1787 )?;
1788 }
1789 }
1790 4 => {
1791 if let Some(field) = &self.certs {
1792 serializer.write_unsigned_integer_sz(
1793 4u64,
1794 fit_sz(
1795 4u64,
1796 self.encodings
1797 .as_ref()
1798 .map(|encs| encs.certs_key_encoding)
1799 .unwrap_or_default(),
1800 force_canonical,
1801 ),
1802 )?;
1803 field.serialize(serializer, force_canonical)?;
1804 }
1805 }
1806 5 => {
1807 if let Some(field) = &self.withdrawals {
1808 serializer.write_unsigned_integer_sz(
1809 5u64,
1810 fit_sz(
1811 5u64,
1812 self.encodings
1813 .as_ref()
1814 .map(|encs| encs.withdrawals_key_encoding)
1815 .unwrap_or_default(),
1816 force_canonical,
1817 ),
1818 )?;
1819 serializer.write_map_sz(
1820 self.encodings
1821 .as_ref()
1822 .map(|encs| encs.withdrawals_encoding)
1823 .unwrap_or_default()
1824 .to_len_sz(field.len() as u64, force_canonical),
1825 )?;
1826 let mut key_order = field
1827 .iter()
1828 .map(|(k, v)| {
1829 let mut buf = cbor_event::se::Serializer::new_vec();
1830 k.serialize(&mut buf, force_canonical)?;
1831 Ok((buf.finalize(), k, v))
1832 })
1833 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
1834 if force_canonical {
1835 key_order.sort_by(
1836 |(lhs_bytes, _, _), (rhs_bytes, _, _)| match lhs_bytes
1837 .len()
1838 .cmp(&rhs_bytes.len())
1839 {
1840 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
1841 diff_ord => diff_ord,
1842 },
1843 );
1844 }
1845 for (key_bytes, key, value) in key_order {
1846 serializer.write_raw_bytes(&key_bytes)?;
1847 let withdrawals_value_encoding = self
1848 .encodings
1849 .as_ref()
1850 .and_then(|encs| encs.withdrawals_value_encodings.get(key))
1851 .cloned()
1852 .unwrap_or_default();
1853 serializer.write_unsigned_integer_sz(
1854 *value,
1855 fit_sz(*value, withdrawals_value_encoding, force_canonical),
1856 )?;
1857 }
1858 self.encodings
1859 .as_ref()
1860 .map(|encs| encs.withdrawals_encoding)
1861 .unwrap_or_default()
1862 .end(serializer, force_canonical)?;
1863 }
1864 }
1865 6 => {
1866 if let Some(field) = &self.auxiliary_data_hash {
1867 serializer.write_unsigned_integer_sz(
1868 7u64,
1869 fit_sz(
1870 7u64,
1871 self.encodings
1872 .as_ref()
1873 .map(|encs| encs.auxiliary_data_hash_key_encoding)
1874 .unwrap_or_default(),
1875 force_canonical,
1876 ),
1877 )?;
1878 serializer.write_bytes_sz(
1879 field.to_raw_bytes(),
1880 self.encodings
1881 .as_ref()
1882 .map(|encs| encs.auxiliary_data_hash_encoding.clone())
1883 .unwrap_or_default()
1884 .to_str_len_sz(field.to_raw_bytes().len() as u64, force_canonical),
1885 )?;
1886 }
1887 }
1888 7 => {
1889 if let Some(field) = &self.validity_interval_start {
1890 serializer.write_unsigned_integer_sz(
1891 8u64,
1892 fit_sz(
1893 8u64,
1894 self.encodings
1895 .as_ref()
1896 .map(|encs| encs.validity_interval_start_key_encoding)
1897 .unwrap_or_default(),
1898 force_canonical,
1899 ),
1900 )?;
1901 serializer.write_unsigned_integer_sz(
1902 *field,
1903 fit_sz(
1904 *field,
1905 self.encodings
1906 .as_ref()
1907 .map(|encs| encs.validity_interval_start_encoding)
1908 .unwrap_or_default(),
1909 force_canonical,
1910 ),
1911 )?;
1912 }
1913 }
1914 8 => {
1915 if let Some(field) = &self.mint {
1916 serializer.write_unsigned_integer_sz(
1917 9u64,
1918 fit_sz(
1919 9u64,
1920 self.encodings
1921 .as_ref()
1922 .map(|encs| encs.mint_key_encoding)
1923 .unwrap_or_default(),
1924 force_canonical,
1925 ),
1926 )?;
1927 serializer.write_map_sz(
1928 self.encodings
1929 .as_ref()
1930 .map(|encs| encs.mint_encoding)
1931 .unwrap_or_default()
1932 .to_len_sz(field.len() as u64, force_canonical),
1933 )?;
1934 let mut key_order = field
1935 .iter()
1936 .map(|(k, v)| {
1937 let mut buf = cbor_event::se::Serializer::new_vec();
1938 let mint_key_encoding = self
1939 .encodings
1940 .as_ref()
1941 .and_then(|encs| encs.mint_key_encodings.get(k))
1942 .cloned()
1943 .unwrap_or_default();
1944 buf.write_bytes_sz(
1945 k.to_raw_bytes(),
1946 mint_key_encoding.to_str_len_sz(
1947 k.to_raw_bytes().len() as u64,
1948 force_canonical,
1949 ),
1950 )?;
1951 Ok((buf.finalize(), k, v))
1952 })
1953 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
1954 if force_canonical {
1955 key_order.sort_by(
1956 |(lhs_bytes, _, _), (rhs_bytes, _, _)| match lhs_bytes
1957 .len()
1958 .cmp(&rhs_bytes.len())
1959 {
1960 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
1961 diff_ord => diff_ord,
1962 },
1963 );
1964 }
1965 for (key_bytes, key, value) in key_order {
1966 serializer.write_raw_bytes(&key_bytes)?;
1967 let (mint_value_encoding, mint_value_value_encodings) = self
1968 .encodings
1969 .as_ref()
1970 .and_then(|encs| encs.mint_value_encodings.get(key))
1971 .cloned()
1972 .unwrap_or_else(|| (LenEncoding::default(), BTreeMap::new()));
1973 serializer.write_map_sz(
1974 mint_value_encoding.to_len_sz(value.len() as u64, force_canonical),
1975 )?;
1976 let mut key_order = value
1977 .iter()
1978 .map(|(k, v)| {
1979 let mut buf = cbor_event::se::Serializer::new_vec();
1980 k.serialize(&mut buf, force_canonical)?;
1981 Ok((buf.finalize(), k, v))
1982 })
1983 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
1984 if force_canonical {
1985 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
1986 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
1987 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
1988 diff_ord => diff_ord,
1989 }
1990 });
1991 }
1992 for (key_bytes, key, value) in key_order {
1993 serializer.write_raw_bytes(&key_bytes)?;
1994 let mint_value_value_encoding = mint_value_value_encodings
1995 .get(key)
1996 .cloned()
1997 .unwrap_or_default();
1998 if *value >= 0 {
1999 serializer.write_unsigned_integer_sz(
2000 *value as u64,
2001 fit_sz(
2002 *value as u64,
2003 mint_value_value_encoding,
2004 force_canonical,
2005 ),
2006 )?;
2007 } else {
2008 serializer.write_negative_integer_sz(
2009 *value as i128,
2010 fit_sz(
2011 (*value + 1).unsigned_abs(),
2012 mint_value_value_encoding,
2013 force_canonical,
2014 ),
2015 )?;
2016 }
2017 }
2018 mint_value_encoding.end(serializer, force_canonical)?;
2019 }
2020 self.encodings
2021 .as_ref()
2022 .map(|encs| encs.mint_encoding)
2023 .unwrap_or_default()
2024 .end(serializer, force_canonical)?;
2025 }
2026 }
2027 9 => {
2028 if let Some(field) = &self.script_data_hash {
2029 serializer.write_unsigned_integer_sz(
2030 11u64,
2031 fit_sz(
2032 11u64,
2033 self.encodings
2034 .as_ref()
2035 .map(|encs| encs.script_data_hash_key_encoding)
2036 .unwrap_or_default(),
2037 force_canonical,
2038 ),
2039 )?;
2040 serializer.write_bytes_sz(
2041 field.to_raw_bytes(),
2042 self.encodings
2043 .as_ref()
2044 .map(|encs| encs.script_data_hash_encoding.clone())
2045 .unwrap_or_default()
2046 .to_str_len_sz(field.to_raw_bytes().len() as u64, force_canonical),
2047 )?;
2048 }
2049 }
2050 10 => {
2051 if let Some(field) = &self.collateral_inputs {
2052 serializer.write_unsigned_integer_sz(
2053 13u64,
2054 fit_sz(
2055 13u64,
2056 self.encodings
2057 .as_ref()
2058 .map(|encs| encs.collateral_inputs_key_encoding)
2059 .unwrap_or_default(),
2060 force_canonical,
2061 ),
2062 )?;
2063 field.serialize(serializer, force_canonical)?;
2064 }
2065 }
2066 11 => {
2067 if let Some(field) = &self.required_signers {
2068 serializer.write_unsigned_integer_sz(
2069 14u64,
2070 fit_sz(
2071 14u64,
2072 self.encodings
2073 .as_ref()
2074 .map(|encs| encs.required_signers_key_encoding)
2075 .unwrap_or_default(),
2076 force_canonical,
2077 ),
2078 )?;
2079 field.serialize(serializer, force_canonical)?;
2080 }
2081 }
2082 12 => {
2083 if let Some(field) = &self.network_id {
2084 serializer.write_unsigned_integer_sz(
2085 15u64,
2086 fit_sz(
2087 15u64,
2088 self.encodings
2089 .as_ref()
2090 .map(|encs| encs.network_id_key_encoding)
2091 .unwrap_or_default(),
2092 force_canonical,
2093 ),
2094 )?;
2095 field.serialize(serializer, force_canonical)?;
2096 }
2097 }
2098 13 => {
2099 if let Some(field) = &self.collateral_return {
2100 serializer.write_unsigned_integer_sz(
2101 16u64,
2102 fit_sz(
2103 16u64,
2104 self.encodings
2105 .as_ref()
2106 .map(|encs| encs.collateral_return_key_encoding)
2107 .unwrap_or_default(),
2108 force_canonical,
2109 ),
2110 )?;
2111 field.serialize(serializer, force_canonical)?;
2112 }
2113 }
2114 14 => {
2115 if let Some(field) = &self.total_collateral {
2116 serializer.write_unsigned_integer_sz(
2117 17u64,
2118 fit_sz(
2119 17u64,
2120 self.encodings
2121 .as_ref()
2122 .map(|encs| encs.total_collateral_key_encoding)
2123 .unwrap_or_default(),
2124 force_canonical,
2125 ),
2126 )?;
2127 serializer.write_unsigned_integer_sz(
2128 *field,
2129 fit_sz(
2130 *field,
2131 self.encodings
2132 .as_ref()
2133 .map(|encs| encs.total_collateral_encoding)
2134 .unwrap_or_default(),
2135 force_canonical,
2136 ),
2137 )?;
2138 }
2139 }
2140 15 => {
2141 if let Some(field) = &self.reference_inputs {
2142 serializer.write_unsigned_integer_sz(
2143 18u64,
2144 fit_sz(
2145 18u64,
2146 self.encodings
2147 .as_ref()
2148 .map(|encs| encs.reference_inputs_key_encoding)
2149 .unwrap_or_default(),
2150 force_canonical,
2151 ),
2152 )?;
2153 field.serialize(serializer, force_canonical)?;
2154 }
2155 }
2156 16 => {
2157 if let Some(field) = &self.voting_procedures {
2158 serializer.write_unsigned_integer_sz(
2159 19u64,
2160 fit_sz(
2161 19u64,
2162 self.encodings
2163 .as_ref()
2164 .map(|encs| encs.voting_procedures_key_encoding)
2165 .unwrap_or_default(),
2166 force_canonical,
2167 ),
2168 )?;
2169 serializer.write_map_sz(
2170 self.encodings
2171 .as_ref()
2172 .map(|encs| encs.voting_procedures_encoding)
2173 .unwrap_or_default()
2174 .to_len_sz(field.len() as u64, force_canonical),
2175 )?;
2176 let mut key_order = field
2177 .iter()
2178 .map(|(k, v)| {
2179 let mut buf = cbor_event::se::Serializer::new_vec();
2180 k.serialize(&mut buf, force_canonical)?;
2181 Ok((buf.finalize(), k, v))
2182 })
2183 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
2184 if force_canonical {
2185 key_order.sort_by(
2186 |(lhs_bytes, _, _), (rhs_bytes, _, _)| match lhs_bytes
2187 .len()
2188 .cmp(&rhs_bytes.len())
2189 {
2190 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
2191 diff_ord => diff_ord,
2192 },
2193 );
2194 }
2195 for (key_bytes, key, value) in key_order {
2196 serializer.write_raw_bytes(&key_bytes)?;
2197 let voting_procedures_value_encoding = self
2198 .encodings
2199 .as_ref()
2200 .and_then(|encs| encs.voting_procedures_value_encodings.get(key))
2201 .cloned()
2202 .unwrap_or_default();
2203 serializer.write_map_sz(
2204 voting_procedures_value_encoding
2205 .to_len_sz(value.len() as u64, force_canonical),
2206 )?;
2207 let mut key_order = value
2208 .iter()
2209 .map(|(k, v)| {
2210 let mut buf = cbor_event::se::Serializer::new_vec();
2211 k.serialize(&mut buf, force_canonical)?;
2212 Ok((buf.finalize(), k, v))
2213 })
2214 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
2215 if force_canonical {
2216 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
2217 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
2218 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
2219 diff_ord => diff_ord,
2220 }
2221 });
2222 }
2223 for (key_bytes, _key, value) in key_order {
2224 serializer.write_raw_bytes(&key_bytes)?;
2225 value.serialize(serializer, force_canonical)?;
2226 }
2227 voting_procedures_value_encoding.end(serializer, force_canonical)?;
2228 }
2229 self.encodings
2230 .as_ref()
2231 .map(|encs| encs.voting_procedures_encoding)
2232 .unwrap_or_default()
2233 .end(serializer, force_canonical)?;
2234 }
2235 }
2236 17 => {
2237 if let Some(field) = &self.proposal_procedures {
2238 serializer.write_unsigned_integer_sz(
2239 20u64,
2240 fit_sz(
2241 20u64,
2242 self.encodings
2243 .as_ref()
2244 .map(|encs| encs.proposal_procedures_key_encoding)
2245 .unwrap_or_default(),
2246 force_canonical,
2247 ),
2248 )?;
2249 field.serialize(serializer, force_canonical)?;
2250 }
2251 }
2252 18 => {
2253 if let Some(field) = &self.current_treasury_value {
2254 serializer.write_unsigned_integer_sz(
2255 21u64,
2256 fit_sz(
2257 21u64,
2258 self.encodings
2259 .as_ref()
2260 .map(|encs| encs.current_treasury_value_key_encoding)
2261 .unwrap_or_default(),
2262 force_canonical,
2263 ),
2264 )?;
2265 serializer.write_unsigned_integer_sz(
2266 *field,
2267 fit_sz(
2268 *field,
2269 self.encodings
2270 .as_ref()
2271 .map(|encs| encs.current_treasury_value_encoding)
2272 .unwrap_or_default(),
2273 force_canonical,
2274 ),
2275 )?;
2276 }
2277 }
2278 19 => {
2279 if let Some(field) = &self.donation {
2280 serializer.write_unsigned_integer_sz(
2281 22u64,
2282 fit_sz(
2283 22u64,
2284 self.encodings
2285 .as_ref()
2286 .map(|encs| encs.donation_key_encoding)
2287 .unwrap_or_default(),
2288 force_canonical,
2289 ),
2290 )?;
2291 serializer.write_unsigned_integer_sz(
2292 *field,
2293 fit_sz(
2294 *field,
2295 self.encodings
2296 .as_ref()
2297 .map(|encs| encs.donation_encoding)
2298 .unwrap_or_default(),
2299 force_canonical,
2300 ),
2301 )?;
2302 }
2303 }
2304 _ => unreachable!(),
2305 };
2306 }
2307 self.encodings
2308 .as_ref()
2309 .map(|encs| encs.len_encoding)
2310 .unwrap_or_default()
2311 .end(serializer, force_canonical)
2312 }
2313}
2314
2315impl Deserialize for TransactionBody {
2316 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2317 let len = raw.map_sz()?;
2318 let len_encoding: LenEncoding = len.into();
2319 let mut read_len = CBORReadLen::new(len);
2320 read_len.read_elems(3)?;
2321 (|| -> Result<_, DeserializeError> {
2322 let mut orig_deser_order = Vec::new();
2323 let mut inputs_key_encoding = None;
2324 let mut inputs = None;
2325 let mut outputs_encoding = LenEncoding::default();
2326 let mut outputs_key_encoding = None;
2327 let mut outputs = None;
2328 let mut fee_encoding = None;
2329 let mut fee_key_encoding = None;
2330 let mut fee = None;
2331 let mut ttl_encoding = None;
2332 let mut ttl_key_encoding = None;
2333 let mut ttl = None;
2334 let mut certs_key_encoding = None;
2335 let mut certs = None;
2336 let mut withdrawals_encoding = LenEncoding::default();
2337 let mut withdrawals_value_encodings = BTreeMap::new();
2338 let mut withdrawals_key_encoding = None;
2339 let mut withdrawals = None;
2340 let mut auxiliary_data_hash_encoding = StringEncoding::default();
2341 let mut auxiliary_data_hash_key_encoding = None;
2342 let mut auxiliary_data_hash = None;
2343 let mut validity_interval_start_encoding = None;
2344 let mut validity_interval_start_key_encoding = None;
2345 let mut validity_interval_start = None;
2346 let mut mint_encoding = LenEncoding::default();
2347 let mut mint_key_encodings = BTreeMap::new();
2348 let mut mint_value_encodings = BTreeMap::new();
2349 let mut mint_key_encoding = None;
2350 let mut mint = None;
2351 let mut script_data_hash_encoding = StringEncoding::default();
2352 let mut script_data_hash_key_encoding = None;
2353 let mut script_data_hash = None;
2354 let mut collateral_inputs_key_encoding = None;
2355 let mut collateral_inputs = None;
2356 let mut required_signers_key_encoding = None;
2357 let mut required_signers = None;
2358 let mut network_id_key_encoding = None;
2359 let mut network_id = None;
2360 let mut collateral_return_key_encoding = None;
2361 let mut collateral_return = None;
2362 let mut total_collateral_encoding = None;
2363 let mut total_collateral_key_encoding = None;
2364 let mut total_collateral = None;
2365 let mut reference_inputs_key_encoding = None;
2366 let mut reference_inputs = None;
2367 let mut voting_procedures_encoding = LenEncoding::default();
2368 let mut voting_procedures_value_encodings = BTreeMap::new();
2369 let mut voting_procedures_key_encoding = None;
2370 let mut voting_procedures = None;
2371 let mut proposal_procedures_key_encoding = None;
2372 let mut proposal_procedures = None;
2373 let mut current_treasury_value_encoding = None;
2374 let mut current_treasury_value_key_encoding = None;
2375 let mut current_treasury_value = None;
2376 let mut donation_encoding = None;
2377 let mut donation_key_encoding = None;
2378 let mut donation = None;
2379 let mut read = 0;
2380 while match len { cbor_event::LenSz::Len(n, _) => read < n, cbor_event::LenSz::Indefinite => true, } {
2381 match raw.cbor_type()? {
2382 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
2383 (0, key_enc) => {
2384 if inputs.is_some() {
2385 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
2386 }
2387 let tmp_inputs = SetTransactionInput::deserialize(raw).map_err(|e: DeserializeError| e.annotate("inputs"))?;
2388 inputs = Some(tmp_inputs);
2389 inputs_key_encoding = Some(key_enc);
2390 orig_deser_order.push(0);
2391 },
2392 (1, key_enc) => {
2393 if outputs.is_some() {
2394 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
2395 }
2396 let (tmp_outputs, tmp_outputs_encoding) = (|| -> Result<_, DeserializeError> {
2397 let mut outputs_arr = Vec::new();
2398 let len = raw.array_sz()?;
2399 let outputs_encoding = len.into();
2400 while match len { cbor_event::LenSz::Len(n, _) => (outputs_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
2401 if raw.cbor_type()? == cbor_event::Type::Special {
2402 assert_eq!(raw.special()?, cbor_event::Special::Break);
2403 break;
2404 }
2405 outputs_arr.push(TransactionOutput::deserialize(raw)?);
2406 }
2407 Ok((outputs_arr, outputs_encoding))
2408 })().map_err(|e| e.annotate("outputs"))?;
2409 outputs = Some(tmp_outputs);
2410 outputs_encoding = tmp_outputs_encoding;
2411 outputs_key_encoding = Some(key_enc);
2412 orig_deser_order.push(1);
2413 },
2414 (2, key_enc) => {
2415 if fee.is_some() {
2416 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
2417 }
2418 let (tmp_fee, tmp_fee_encoding) = raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc))).map_err(|e: DeserializeError| e.annotate("fee"))?;
2419 fee = Some(tmp_fee);
2420 fee_encoding = tmp_fee_encoding;
2421 fee_key_encoding = Some(key_enc);
2422 orig_deser_order.push(2);
2423 },
2424 (3, key_enc) => {
2425 if ttl.is_some() {
2426 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
2427 }
2428 let (tmp_ttl, tmp_ttl_encoding) = (|| -> Result<_, DeserializeError> {
2429 read_len.read_elems(1)?;
2430 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
2431 })().map_err(|e| e.annotate("ttl"))?;
2432 ttl = Some(tmp_ttl);
2433 ttl_encoding = tmp_ttl_encoding;
2434 ttl_key_encoding = Some(key_enc);
2435 orig_deser_order.push(3);
2436 },
2437 (4, key_enc) => {
2438 if certs.is_some() {
2439 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
2440 }
2441 let tmp_certs = (|| -> Result<_, DeserializeError> {
2442 read_len.read_elems(1)?;
2443 NonemptySetCertificate::deserialize(raw)
2444 })().map_err(|e| e.annotate("certs"))?;
2445 certs = Some(tmp_certs);
2446 certs_key_encoding = Some(key_enc);
2447 orig_deser_order.push(4);
2448 },
2449 (5, key_enc) => {
2450 if withdrawals.is_some() {
2451 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
2452 }
2453 let (tmp_withdrawals, tmp_withdrawals_encoding, tmp_withdrawals_value_encodings) = (|| -> Result<_, DeserializeError> {
2454 read_len.read_elems(1)?;
2455 let mut withdrawals_table = OrderedHashMap::new();
2456 let withdrawals_len = raw.map_sz()?;
2457 let withdrawals_encoding = withdrawals_len.into();
2458 let mut withdrawals_value_encodings = BTreeMap::new();
2459 while match withdrawals_len { cbor_event::LenSz::Len(n, _) => (withdrawals_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
2460 if raw.cbor_type()? == cbor_event::Type::Special {
2461 assert_eq!(raw.special()?, cbor_event::Special::Break);
2462 break;
2463 }
2464 let withdrawals_key = RewardAccount::deserialize(raw)?;
2465 let (withdrawals_value, withdrawals_value_encoding) = raw.unsigned_integer_sz().map(|(x, enc)| (x, Some(enc)))?;
2466 if withdrawals_table.insert(withdrawals_key.clone(), withdrawals_value).is_some() {
2467 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
2468 }
2469 withdrawals_value_encodings.insert(withdrawals_key, withdrawals_value_encoding);
2470 }
2471 Ok((withdrawals_table, withdrawals_encoding, withdrawals_value_encodings))
2472 })().map_err(|e| e.annotate("withdrawals"))?;
2473 withdrawals = Some(tmp_withdrawals);
2474 withdrawals_encoding = tmp_withdrawals_encoding;
2475 withdrawals_value_encodings = tmp_withdrawals_value_encodings;
2476 withdrawals_key_encoding = Some(key_enc);
2477 orig_deser_order.push(5);
2478 },
2479 (7, key_enc) => {
2480 if auxiliary_data_hash.is_some() {
2481 return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
2482 }
2483 let (tmp_auxiliary_data_hash, tmp_auxiliary_data_hash_encoding) = (|| -> Result<_, DeserializeError> {
2484 read_len.read_elems(1)?;
2485 raw.bytes_sz().map_err(Into::<DeserializeError>::into).and_then(|(bytes, enc)| AuxiliaryDataHash::from_raw_bytes(&bytes).map(|bytes| (bytes, StringEncoding::from(enc))).map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into()))
2486 })().map_err(|e| e.annotate("auxiliary_data_hash"))?;
2487 auxiliary_data_hash = Some(tmp_auxiliary_data_hash);
2488 auxiliary_data_hash_encoding = tmp_auxiliary_data_hash_encoding;
2489 auxiliary_data_hash_key_encoding = Some(key_enc);
2490 orig_deser_order.push(6);
2491 },
2492 (8, key_enc) => {
2493 if validity_interval_start.is_some() {
2494 return Err(DeserializeFailure::DuplicateKey(Key::Uint(8)).into());
2495 }
2496 let (tmp_validity_interval_start, tmp_validity_interval_start_encoding) = (|| -> Result<_, DeserializeError> {
2497 read_len.read_elems(1)?;
2498 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
2499 })().map_err(|e| e.annotate("validity_interval_start"))?;
2500 validity_interval_start = Some(tmp_validity_interval_start);
2501 validity_interval_start_encoding = tmp_validity_interval_start_encoding;
2502 validity_interval_start_key_encoding = Some(key_enc);
2503 orig_deser_order.push(7);
2504 },
2505 (9, key_enc) => {
2506 if mint.is_some() {
2507 return Err(DeserializeFailure::DuplicateKey(Key::Uint(9)).into());
2508 }
2509 let (tmp_mint, tmp_mint_encoding, tmp_mint_key_encodings, tmp_mint_value_encodings) = (|| -> Result<_, DeserializeError> {
2510 read_len.read_elems(1)?;
2511 let mut mint_table = OrderedHashMap::new();
2512 let mint_len = raw.map_sz()?;
2513 let mint_encoding = mint_len.into();
2514 let mut mint_key_encodings = BTreeMap::new();
2515 let mut mint_value_encodings = BTreeMap::new();
2516 while match mint_len { cbor_event::LenSz::Len(n, _) => (mint_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
2517 if raw.cbor_type()? == cbor_event::Type::Special {
2518 assert_eq!(raw.special()?, cbor_event::Special::Break);
2519 break;
2520 }
2521 let (mint_key, mint_key_encoding) = raw.bytes_sz().map_err(Into::<DeserializeError>::into).and_then(|(bytes, enc)| ScriptHash::from_raw_bytes(&bytes).map(|bytes| (bytes, StringEncoding::from(enc))).map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into()))?;
2522 let mut mint_value_table = OrderedHashMap::new();
2523 let mint_value_len = raw.map_sz()?;
2524 let mint_value_encoding = mint_value_len.into();
2525 let mut mint_value_value_encodings = BTreeMap::new();
2526 while match mint_value_len { cbor_event::LenSz::Len(n, _) => (mint_value_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
2527 if raw.cbor_type()? == cbor_event::Type::Special {
2528 assert_eq!(raw.special()?, cbor_event::Special::Break);
2529 break;
2530 }
2531 let mint_value_key = AssetName::deserialize(raw)?;
2532 let (mint_value_value, mint_value_value_encoding) = match raw.cbor_type()? {
2533 cbor_event::Type::UnsignedInteger => {
2534 let (x, enc) = raw.unsigned_integer_sz()?;
2535 (x as i64, Some(enc))
2536 },
2537 _ => {
2538 let (x, enc) = raw.negative_integer_sz()?;
2539 (x as i64, Some(enc))
2540 },
2541 };
2542 if mint_value_table.insert(mint_value_key.clone(), mint_value_value).is_some() {
2543 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
2544 }
2545 mint_value_value_encodings.insert(mint_value_key, mint_value_value_encoding);
2546 }
2547 let (mint_value, mint_value_encoding, mint_value_value_encodings) = (mint_value_table, mint_value_encoding, mint_value_value_encodings);
2548 if mint_table.insert(mint_key, mint_value).is_some() {
2549 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
2550 }
2551 mint_key_encodings.insert(mint_key, mint_key_encoding);
2552 mint_value_encodings.insert(mint_key, (mint_value_encoding, mint_value_value_encodings));
2553 }
2554 Ok((mint_table, mint_encoding, mint_key_encodings, mint_value_encodings))
2555 })().map_err(|e| e.annotate("mint"))?;
2556 mint = Some(tmp_mint);
2557 mint_encoding = tmp_mint_encoding;
2558 mint_key_encodings = tmp_mint_key_encodings;
2559 mint_value_encodings = tmp_mint_value_encodings;
2560 mint_key_encoding = Some(key_enc);
2561 orig_deser_order.push(8);
2562 },
2563 (11, key_enc) => {
2564 if script_data_hash.is_some() {
2565 return Err(DeserializeFailure::DuplicateKey(Key::Uint(11)).into());
2566 }
2567 let (tmp_script_data_hash, tmp_script_data_hash_encoding) = (|| -> Result<_, DeserializeError> {
2568 read_len.read_elems(1)?;
2569 raw.bytes_sz().map_err(Into::<DeserializeError>::into).and_then(|(bytes, enc)| ScriptDataHash::from_raw_bytes(&bytes).map(|bytes| (bytes, StringEncoding::from(enc))).map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into()))
2570 })().map_err(|e| e.annotate("script_data_hash"))?;
2571 script_data_hash = Some(tmp_script_data_hash);
2572 script_data_hash_encoding = tmp_script_data_hash_encoding;
2573 script_data_hash_key_encoding = Some(key_enc);
2574 orig_deser_order.push(9);
2575 },
2576 (13, key_enc) => {
2577 if collateral_inputs.is_some() {
2578 return Err(DeserializeFailure::DuplicateKey(Key::Uint(13)).into());
2579 }
2580 let tmp_collateral_inputs = (|| -> Result<_, DeserializeError> {
2581 read_len.read_elems(1)?;
2582 NonemptySetTransactionInput::deserialize(raw)
2583 })().map_err(|e| e.annotate("collateral_inputs"))?;
2584 collateral_inputs = Some(tmp_collateral_inputs);
2585 collateral_inputs_key_encoding = Some(key_enc);
2586 orig_deser_order.push(10);
2587 },
2588 (14, key_enc) => {
2589 if required_signers.is_some() {
2590 return Err(DeserializeFailure::DuplicateKey(Key::Uint(14)).into());
2591 }
2592 let tmp_required_signers = (|| -> Result<_, DeserializeError> {
2593 read_len.read_elems(1)?;
2594 RequiredSigners::deserialize(raw)
2595 })().map_err(|e| e.annotate("required_signers"))?;
2596 required_signers = Some(tmp_required_signers);
2597 required_signers_key_encoding = Some(key_enc);
2598 orig_deser_order.push(11);
2599 },
2600 (15, key_enc) => {
2601 if network_id.is_some() {
2602 return Err(DeserializeFailure::DuplicateKey(Key::Uint(15)).into());
2603 }
2604 let tmp_network_id = (|| -> Result<_, DeserializeError> {
2605 read_len.read_elems(1)?;
2606 NetworkId::deserialize(raw)
2607 })().map_err(|e| e.annotate("network_id"))?;
2608 network_id = Some(tmp_network_id);
2609 network_id_key_encoding = Some(key_enc);
2610 orig_deser_order.push(12);
2611 },
2612 (16, key_enc) => {
2613 if collateral_return.is_some() {
2614 return Err(DeserializeFailure::DuplicateKey(Key::Uint(16)).into());
2615 }
2616 let tmp_collateral_return = (|| -> Result<_, DeserializeError> {
2617 read_len.read_elems(1)?;
2618 TransactionOutput::deserialize(raw)
2619 })().map_err(|e| e.annotate("collateral_return"))?;
2620 collateral_return = Some(tmp_collateral_return);
2621 collateral_return_key_encoding = Some(key_enc);
2622 orig_deser_order.push(13);
2623 },
2624 (17, key_enc) => {
2625 if total_collateral.is_some() {
2626 return Err(DeserializeFailure::DuplicateKey(Key::Uint(17)).into());
2627 }
2628 let (tmp_total_collateral, tmp_total_collateral_encoding) = (|| -> Result<_, DeserializeError> {
2629 read_len.read_elems(1)?;
2630 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
2631 })().map_err(|e| e.annotate("total_collateral"))?;
2632 total_collateral = Some(tmp_total_collateral);
2633 total_collateral_encoding = tmp_total_collateral_encoding;
2634 total_collateral_key_encoding = Some(key_enc);
2635 orig_deser_order.push(14);
2636 },
2637 (18, key_enc) => {
2638 if reference_inputs.is_some() {
2639 return Err(DeserializeFailure::DuplicateKey(Key::Uint(18)).into());
2640 }
2641 let tmp_reference_inputs = (|| -> Result<_, DeserializeError> {
2642 read_len.read_elems(1)?;
2643 NonemptySetTransactionInput::deserialize(raw)
2644 })().map_err(|e| e.annotate("reference_inputs"))?;
2645 reference_inputs = Some(tmp_reference_inputs);
2646 reference_inputs_key_encoding = Some(key_enc);
2647 orig_deser_order.push(15);
2648 },
2649 (19, key_enc) => {
2650 if voting_procedures.is_some() {
2651 return Err(DeserializeFailure::DuplicateKey(Key::Uint(19)).into());
2652 }
2653 let (tmp_voting_procedures, tmp_voting_procedures_encoding, tmp_voting_procedures_value_encodings) = (|| -> Result<_, DeserializeError> {
2654 read_len.read_elems(1)?;
2655 let mut voting_procedures_table = OrderedHashMap::new();
2656 let voting_procedures_len = raw.map_sz()?;
2657 let voting_procedures_encoding = voting_procedures_len.into();
2658 let mut voting_procedures_value_encodings = BTreeMap::new();
2659 while match voting_procedures_len { cbor_event::LenSz::Len(n, _) => (voting_procedures_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
2660 if raw.cbor_type()? == cbor_event::Type::Special {
2661 assert_eq!(raw.special()?, cbor_event::Special::Break);
2662 break;
2663 }
2664 let voting_procedures_key = Voter::deserialize(raw)?;
2665 let mut voting_procedures_value_table = OrderedHashMap::new();
2666 let voting_procedures_value_len = raw.map_sz()?;
2667 let voting_procedures_value_encoding = voting_procedures_value_len.into();
2668 while match voting_procedures_value_len { cbor_event::LenSz::Len(n, _) => (voting_procedures_value_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
2669 if raw.cbor_type()? == cbor_event::Type::Special {
2670 assert_eq!(raw.special()?, cbor_event::Special::Break);
2671 break;
2672 }
2673 let voting_procedures_value_key = GovActionId::deserialize(raw)?;
2674 let voting_procedures_value_value = VotingProcedure::deserialize(raw)?;
2675 if voting_procedures_value_table.insert(voting_procedures_value_key.clone(), voting_procedures_value_value).is_some() {
2676 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
2677 }
2678 }
2679 let (voting_procedures_value, voting_procedures_value_encoding) = (voting_procedures_value_table, voting_procedures_value_encoding);
2680 if voting_procedures_table.insert(voting_procedures_key.clone(), voting_procedures_value).is_some() {
2681 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
2682 }
2683 voting_procedures_value_encodings.insert(voting_procedures_key, voting_procedures_value_encoding);
2684 }
2685 Ok((voting_procedures_table, voting_procedures_encoding, voting_procedures_value_encodings))
2686 })().map_err(|e| e.annotate("voting_procedures"))?;
2687 voting_procedures = Some(tmp_voting_procedures);
2688 voting_procedures_encoding = tmp_voting_procedures_encoding;
2689 voting_procedures_value_encodings = tmp_voting_procedures_value_encodings;
2690 voting_procedures_key_encoding = Some(key_enc);
2691 orig_deser_order.push(16);
2692 },
2693 (20, key_enc) => {
2694 if proposal_procedures.is_some() {
2695 return Err(DeserializeFailure::DuplicateKey(Key::Uint(20)).into());
2696 }
2697 let tmp_proposal_procedures = (|| -> Result<_, DeserializeError> {
2698 read_len.read_elems(1)?;
2699 NonemptySetProposalProcedure::deserialize(raw)
2700 })().map_err(|e| e.annotate("proposal_procedures"))?;
2701 proposal_procedures = Some(tmp_proposal_procedures);
2702 proposal_procedures_key_encoding = Some(key_enc);
2703 orig_deser_order.push(17);
2704 },
2705 (21, key_enc) => {
2706 if current_treasury_value.is_some() {
2707 return Err(DeserializeFailure::DuplicateKey(Key::Uint(21)).into());
2708 }
2709 let (tmp_current_treasury_value, tmp_current_treasury_value_encoding) = (|| -> Result<_, DeserializeError> {
2710 read_len.read_elems(1)?;
2711 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
2712 })().map_err(|e| e.annotate("current_treasury_value"))?;
2713 current_treasury_value = Some(tmp_current_treasury_value);
2714 current_treasury_value_encoding = tmp_current_treasury_value_encoding;
2715 current_treasury_value_key_encoding = Some(key_enc);
2716 orig_deser_order.push(18);
2717 },
2718 (22, key_enc) => {
2719 if donation.is_some() {
2720 return Err(DeserializeFailure::DuplicateKey(Key::Uint(22)).into());
2721 }
2722 let (tmp_donation, tmp_donation_encoding) = (|| -> Result<_, DeserializeError> {
2723 read_len.read_elems(1)?;
2724 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
2725 })().map_err(|e| e.annotate("donation"))?;
2726 donation = Some(tmp_donation);
2727 donation_encoding = tmp_donation_encoding;
2728 donation_key_encoding = Some(key_enc);
2729 orig_deser_order.push(19);
2730 },
2731 (unknown_key, _enc) => return Err(DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()),
2732 },
2733 cbor_event::Type::Text => return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into()),
2734 cbor_event::Type::Special => match len {
2735 cbor_event::LenSz::Len(_, _) => return Err(DeserializeFailure::BreakInDefiniteLen.into()),
2736 cbor_event::LenSz::Indefinite => match raw.special()? {
2737 cbor_event::Special::Break => break,
2738 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2739 },
2740 },
2741 other_type => return Err(DeserializeFailure::UnexpectedKeyType(other_type).into()),
2742 }
2743 read += 1;
2744 }
2745 let inputs = match inputs {
2746 Some(x) => x,
2747 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(0)).into()),
2748 };
2749 let outputs = match outputs {
2750 Some(x) => x,
2751 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
2752 };
2753 let fee = match fee {
2754 Some(x) => x,
2755 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(2)).into()),
2756 };
2757 read_len.finish()?;
2758 Ok(Self {
2759 inputs,
2760 outputs,
2761 fee,
2762 ttl,
2763 certs,
2764 withdrawals,
2765 auxiliary_data_hash,
2766 validity_interval_start,
2767 mint: mint.map(Into::into),
2769 script_data_hash,
2770 collateral_inputs,
2771 required_signers,
2772 network_id,
2773 collateral_return,
2774 total_collateral,
2775 reference_inputs,
2776 voting_procedures,
2777 proposal_procedures,
2778 current_treasury_value,
2779 donation,
2780 encodings: Some(TransactionBodyEncoding {
2781 len_encoding,
2782 orig_deser_order,
2783 inputs_key_encoding,
2784 outputs_key_encoding,
2785 outputs_encoding,
2786 fee_key_encoding,
2787 fee_encoding,
2788 ttl_key_encoding,
2789 ttl_encoding,
2790 certs_key_encoding,
2791 withdrawals_key_encoding,
2792 withdrawals_encoding,
2793 withdrawals_value_encodings,
2794 auxiliary_data_hash_key_encoding,
2795 auxiliary_data_hash_encoding,
2796 validity_interval_start_key_encoding,
2797 validity_interval_start_encoding,
2798 mint_key_encoding,
2799 mint_encoding,
2800 mint_key_encodings,
2801 mint_value_encodings,
2802 script_data_hash_key_encoding,
2803 script_data_hash_encoding,
2804 collateral_inputs_key_encoding,
2805 required_signers_key_encoding,
2806 network_id_key_encoding,
2807 collateral_return_key_encoding,
2808 total_collateral_key_encoding,
2809 total_collateral_encoding,
2810 reference_inputs_key_encoding,
2811 voting_procedures_key_encoding,
2812 voting_procedures_encoding,
2813 voting_procedures_value_encodings,
2814 proposal_procedures_key_encoding,
2815 current_treasury_value_key_encoding,
2816 current_treasury_value_encoding,
2817 donation_key_encoding,
2818 donation_encoding,
2819 }),
2820 })
2821 })().map_err(|e| e.annotate("TransactionBody"))
2822 }
2823}
2824
2825impl Serialize for TransactionInput {
2826 fn serialize<'se, W: Write>(
2827 &self,
2828 serializer: &'se mut Serializer<W>,
2829 force_canonical: bool,
2830 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2831 serializer.write_array_sz(
2832 self.encodings
2833 .as_ref()
2834 .map(|encs| encs.len_encoding)
2835 .unwrap_or_default()
2836 .to_len_sz(2, force_canonical),
2837 )?;
2838 serializer.write_bytes_sz(
2839 self.transaction_id.to_raw_bytes(),
2840 self.encodings
2841 .as_ref()
2842 .map(|encs| encs.transaction_id_encoding.clone())
2843 .unwrap_or_default()
2844 .to_str_len_sz(
2845 self.transaction_id.to_raw_bytes().len() as u64,
2846 force_canonical,
2847 ),
2848 )?;
2849 serializer.write_unsigned_integer_sz(
2850 self.index,
2851 fit_sz(
2852 self.index,
2853 self.encodings
2854 .as_ref()
2855 .map(|encs| encs.index_encoding)
2856 .unwrap_or_default(),
2857 force_canonical,
2858 ),
2859 )?;
2860 self.encodings
2861 .as_ref()
2862 .map(|encs| encs.len_encoding)
2863 .unwrap_or_default()
2864 .end(serializer, force_canonical)
2865 }
2866}
2867
2868impl Deserialize for TransactionInput {
2869 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2870 let len = raw.array_sz()?;
2871 let len_encoding: LenEncoding = len.into();
2872 let mut read_len = CBORReadLen::new(len);
2873 read_len.read_elems(2)?;
2874 read_len.finish()?;
2875 (|| -> Result<_, DeserializeError> {
2876 let (transaction_id, transaction_id_encoding) = raw
2877 .bytes_sz()
2878 .map_err(Into::<DeserializeError>::into)
2879 .and_then(|(bytes, enc)| {
2880 TransactionHash::from_raw_bytes(&bytes)
2881 .map(|bytes| (bytes, StringEncoding::from(enc)))
2882 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
2883 })
2884 .map_err(|e: DeserializeError| e.annotate("transaction_id"))?;
2885 let (index, index_encoding) = raw
2886 .unsigned_integer_sz()
2887 .map_err(Into::<DeserializeError>::into)
2888 .map(|(x, enc)| (x, Some(enc)))
2889 .map_err(|e: DeserializeError| e.annotate("index"))?;
2890 match len {
2891 cbor_event::LenSz::Len(_, _) => (),
2892 cbor_event::LenSz::Indefinite => match raw.special()? {
2893 cbor_event::Special::Break => (),
2894 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2895 },
2896 }
2897 Ok(TransactionInput {
2898 transaction_id,
2899 index,
2900 encodings: Some(TransactionInputEncoding {
2901 len_encoding,
2902 transaction_id_encoding,
2903 index_encoding,
2904 }),
2905 })
2906 })()
2907 .map_err(|e| e.annotate("TransactionInput"))
2908 }
2909}
2910
2911impl Serialize for TransactionOutput {
2912 fn serialize<'se, W: Write>(
2913 &self,
2914 serializer: &'se mut Serializer<W>,
2915 force_canonical: bool,
2916 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2917 match self {
2918 TransactionOutput::AlonzoFormatTxOut(alonzo_format_tx_out) => {
2919 alonzo_format_tx_out.serialize(serializer, force_canonical)
2920 }
2921 TransactionOutput::ConwayFormatTxOut(conway_format_tx_out) => {
2922 conway_format_tx_out.serialize(serializer, force_canonical)
2923 }
2924 }
2925 }
2926}
2927
2928impl Deserialize for TransactionOutput {
2929 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2930 (|| -> Result<_, DeserializeError> {
2931 match raw.cbor_type()? {
2932 cbor_event::Type::Array => Ok(TransactionOutput::AlonzoFormatTxOut(
2933 AlonzoFormatTxOut::deserialize(raw)?,
2934 )),
2935 cbor_event::Type::Map => Ok(TransactionOutput::ConwayFormatTxOut(
2936 ConwayFormatTxOut::deserialize(raw)?,
2937 )),
2938 _ => Err(DeserializeError::new(
2939 "TransactionOutput",
2940 DeserializeFailure::NoVariantMatched,
2941 )),
2942 }
2943 })()
2944 .map_err(|e| e.annotate("TransactionOutput"))
2945 }
2946}
2947
2948impl Serialize for TransactionWitnessSet {
2949 fn serialize<'se, W: Write>(
2950 &self,
2951 serializer: &'se mut Serializer<W>,
2952 force_canonical: bool,
2953 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2954 serializer.write_map_sz(
2955 self.encodings
2956 .as_ref()
2957 .map(|encs| encs.len_encoding)
2958 .unwrap_or_default()
2959 .to_len_sz(
2960 match &self.vkeywitnesses {
2961 Some(_) => 1,
2962 None => 0,
2963 } + match &self.native_scripts {
2964 Some(_) => 1,
2965 None => 0,
2966 } + match &self.bootstrap_witnesses {
2967 Some(_) => 1,
2968 None => 0,
2969 } + match &self.plutus_v1_scripts {
2970 Some(_) => 1,
2971 None => 0,
2972 } + match &self.plutus_datums {
2973 Some(_) => 1,
2974 None => 0,
2975 } + match &self.redeemers {
2976 Some(_) => 1,
2977 None => 0,
2978 } + match &self.plutus_v2_scripts {
2979 Some(_) => 1,
2980 None => 0,
2981 } + match &self.plutus_v3_scripts {
2982 Some(_) => 1,
2983 None => 0,
2984 },
2985 force_canonical,
2986 ),
2987 )?;
2988 let deser_order = self
2989 .encodings
2990 .as_ref()
2991 .filter(|encs| {
2992 !force_canonical
2993 && encs.orig_deser_order.len()
2994 == match &self.vkeywitnesses {
2995 Some(_) => 1,
2996 None => 0,
2997 } + match &self.native_scripts {
2998 Some(_) => 1,
2999 None => 0,
3000 } + match &self.bootstrap_witnesses {
3001 Some(_) => 1,
3002 None => 0,
3003 } + match &self.plutus_v1_scripts {
3004 Some(_) => 1,
3005 None => 0,
3006 } + match &self.plutus_datums {
3007 Some(_) => 1,
3008 None => 0,
3009 } + match &self.redeemers {
3010 Some(_) => 1,
3011 None => 0,
3012 } + match &self.plutus_v2_scripts {
3013 Some(_) => 1,
3014 None => 0,
3015 } + match &self.plutus_v3_scripts {
3016 Some(_) => 1,
3017 None => 0,
3018 }
3019 })
3020 .map(|encs| encs.orig_deser_order.clone())
3021 .unwrap_or_else(|| vec![0, 1, 2, 3, 4, 5, 6, 7]);
3022 for field_index in deser_order {
3023 match field_index {
3024 0 => {
3025 if let Some(field) = &self.vkeywitnesses {
3026 serializer.write_unsigned_integer_sz(
3027 0u64,
3028 fit_sz(
3029 0u64,
3030 self.encodings
3031 .as_ref()
3032 .map(|encs| encs.vkeywitnesses_key_encoding)
3033 .unwrap_or_default(),
3034 force_canonical,
3035 ),
3036 )?;
3037 field.serialize(serializer, force_canonical)?;
3038 }
3039 }
3040 1 => {
3041 if let Some(field) = &self.native_scripts {
3042 serializer.write_unsigned_integer_sz(
3043 1u64,
3044 fit_sz(
3045 1u64,
3046 self.encodings
3047 .as_ref()
3048 .map(|encs| encs.native_scripts_key_encoding)
3049 .unwrap_or_default(),
3050 force_canonical,
3051 ),
3052 )?;
3053 field.serialize(serializer, force_canonical)?;
3054 }
3055 }
3056 2 => {
3057 if let Some(field) = &self.bootstrap_witnesses {
3058 serializer.write_unsigned_integer_sz(
3059 2u64,
3060 fit_sz(
3061 2u64,
3062 self.encodings
3063 .as_ref()
3064 .map(|encs| encs.bootstrap_witnesses_key_encoding)
3065 .unwrap_or_default(),
3066 force_canonical,
3067 ),
3068 )?;
3069 field.serialize(serializer, force_canonical)?;
3070 }
3071 }
3072 3 => {
3073 if let Some(field) = &self.plutus_v1_scripts {
3074 serializer.write_unsigned_integer_sz(
3075 3u64,
3076 fit_sz(
3077 3u64,
3078 self.encodings
3079 .as_ref()
3080 .map(|encs| encs.plutus_v1_scripts_key_encoding)
3081 .unwrap_or_default(),
3082 force_canonical,
3083 ),
3084 )?;
3085 field.serialize(serializer, force_canonical)?;
3086 }
3087 }
3088 4 => {
3089 if let Some(field) = &self.plutus_datums {
3090 serializer.write_unsigned_integer_sz(
3091 4u64,
3092 fit_sz(
3093 4u64,
3094 self.encodings
3095 .as_ref()
3096 .map(|encs| encs.plutus_datums_key_encoding)
3097 .unwrap_or_default(),
3098 force_canonical,
3099 ),
3100 )?;
3101 field.serialize(serializer, force_canonical)?;
3102 }
3103 }
3104 5 => {
3105 if let Some(field) = &self.redeemers {
3106 serializer.write_unsigned_integer_sz(
3107 5u64,
3108 fit_sz(
3109 5u64,
3110 self.encodings
3111 .as_ref()
3112 .map(|encs| encs.redeemers_key_encoding)
3113 .unwrap_or_default(),
3114 force_canonical,
3115 ),
3116 )?;
3117 field.serialize(serializer, force_canonical)?;
3118 }
3119 }
3120 6 => {
3121 if let Some(field) = &self.plutus_v2_scripts {
3122 serializer.write_unsigned_integer_sz(
3123 6u64,
3124 fit_sz(
3125 6u64,
3126 self.encodings
3127 .as_ref()
3128 .map(|encs| encs.plutus_v2_scripts_key_encoding)
3129 .unwrap_or_default(),
3130 force_canonical,
3131 ),
3132 )?;
3133 field.serialize(serializer, force_canonical)?;
3134 }
3135 }
3136 7 => {
3137 if let Some(field) = &self.plutus_v3_scripts {
3138 serializer.write_unsigned_integer_sz(
3139 7u64,
3140 fit_sz(
3141 7u64,
3142 self.encodings
3143 .as_ref()
3144 .map(|encs| encs.plutus_v3_scripts_key_encoding)
3145 .unwrap_or_default(),
3146 force_canonical,
3147 ),
3148 )?;
3149 field.serialize(serializer, force_canonical)?;
3150 }
3151 }
3152 _ => unreachable!(),
3153 };
3154 }
3155 self.encodings
3156 .as_ref()
3157 .map(|encs| encs.len_encoding)
3158 .unwrap_or_default()
3159 .end(serializer, force_canonical)
3160 }
3161}
3162
3163impl Deserialize for TransactionWitnessSet {
3164 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3165 let len = raw.map_sz()?;
3166 let len_encoding: LenEncoding = len.into();
3167 let mut read_len = CBORReadLen::new(len);
3168 (|| -> Result<_, DeserializeError> {
3169 let mut orig_deser_order = Vec::new();
3170 let mut vkeywitnesses_key_encoding = None;
3171 let mut vkeywitnesses = None;
3172 let mut native_scripts_key_encoding = None;
3173 let mut native_scripts = None;
3174 let mut bootstrap_witnesses_key_encoding = None;
3175 let mut bootstrap_witnesses = None;
3176 let mut plutus_v1_scripts_key_encoding = None;
3177 let mut plutus_v1_scripts = None;
3178 let mut plutus_datums_key_encoding = None;
3179 let mut plutus_datums = None;
3180 let mut redeemers_key_encoding = None;
3181 let mut redeemers = None;
3182 let mut plutus_v2_scripts_key_encoding = None;
3183 let mut plutus_v2_scripts = None;
3184 let mut plutus_v3_scripts_key_encoding = None;
3185 let mut plutus_v3_scripts = None;
3186 let mut read = 0;
3187 while match len {
3188 cbor_event::LenSz::Len(n, _) => read < n,
3189 cbor_event::LenSz::Indefinite => true,
3190 } {
3191 match raw.cbor_type()? {
3192 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
3193 (0, key_enc) => {
3194 if vkeywitnesses.is_some() {
3195 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
3196 }
3197 let tmp_vkeywitnesses = (|| -> Result<_, DeserializeError> {
3198 read_len.read_elems(1)?;
3199 NonemptySetVkeywitness::deserialize(raw)
3200 })()
3201 .map_err(|e| e.annotate("vkeywitnesses"))?;
3202 vkeywitnesses = Some(tmp_vkeywitnesses);
3203 vkeywitnesses_key_encoding = Some(key_enc);
3204 orig_deser_order.push(0);
3205 }
3206 (1, key_enc) => {
3207 if native_scripts.is_some() {
3208 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
3209 }
3210 let tmp_native_scripts = (|| -> Result<_, DeserializeError> {
3211 read_len.read_elems(1)?;
3212 NonemptySetNativeScript::deserialize(raw)
3213 })()
3214 .map_err(|e| e.annotate("native_scripts"))?;
3215 native_scripts = Some(tmp_native_scripts);
3216 native_scripts_key_encoding = Some(key_enc);
3217 orig_deser_order.push(1);
3218 }
3219 (2, key_enc) => {
3220 if bootstrap_witnesses.is_some() {
3221 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
3222 }
3223 let tmp_bootstrap_witnesses = (|| -> Result<_, DeserializeError> {
3224 read_len.read_elems(1)?;
3225 NonemptySetBootstrapWitness::deserialize(raw)
3226 })()
3227 .map_err(|e| e.annotate("bootstrap_witnesses"))?;
3228 bootstrap_witnesses = Some(tmp_bootstrap_witnesses);
3229 bootstrap_witnesses_key_encoding = Some(key_enc);
3230 orig_deser_order.push(2);
3231 }
3232 (3, key_enc) => {
3233 if plutus_v1_scripts.is_some() {
3234 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
3235 }
3236 let tmp_plutus_v1_scripts = (|| -> Result<_, DeserializeError> {
3237 read_len.read_elems(1)?;
3238 NonemptySetPlutusV1Script::deserialize(raw)
3239 })()
3240 .map_err(|e| e.annotate("plutus_v1_scripts"))?;
3241 plutus_v1_scripts = Some(tmp_plutus_v1_scripts);
3242 plutus_v1_scripts_key_encoding = Some(key_enc);
3243 orig_deser_order.push(3);
3244 }
3245 (4, key_enc) => {
3246 if plutus_datums.is_some() {
3247 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
3248 }
3249 let tmp_plutus_datums = (|| -> Result<_, DeserializeError> {
3250 read_len.read_elems(1)?;
3251 NonemptySetPlutusData::deserialize(raw)
3252 })()
3253 .map_err(|e| e.annotate("plutus_datums"))?;
3254 plutus_datums = Some(tmp_plutus_datums);
3255 plutus_datums_key_encoding = Some(key_enc);
3256 orig_deser_order.push(4);
3257 }
3258 (5, key_enc) => {
3259 if redeemers.is_some() {
3260 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
3261 }
3262 let tmp_redeemers = (|| -> Result<_, DeserializeError> {
3263 read_len.read_elems(1)?;
3264 Redeemers::deserialize(raw)
3265 })()
3266 .map_err(|e| e.annotate("redeemers"))?;
3267 redeemers = Some(tmp_redeemers);
3268 redeemers_key_encoding = Some(key_enc);
3269 orig_deser_order.push(5);
3270 }
3271 (6, key_enc) => {
3272 if plutus_v2_scripts.is_some() {
3273 return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
3274 }
3275 let tmp_plutus_v2_scripts = (|| -> Result<_, DeserializeError> {
3276 read_len.read_elems(1)?;
3277 NonemptySetPlutusV2Script::deserialize(raw)
3278 })()
3279 .map_err(|e| e.annotate("plutus_v2_scripts"))?;
3280 plutus_v2_scripts = Some(tmp_plutus_v2_scripts);
3281 plutus_v2_scripts_key_encoding = Some(key_enc);
3282 orig_deser_order.push(6);
3283 }
3284 (7, key_enc) => {
3285 if plutus_v3_scripts.is_some() {
3286 return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
3287 }
3288 let tmp_plutus_v3_scripts = (|| -> Result<_, DeserializeError> {
3289 read_len.read_elems(1)?;
3290 NonemptySetPlutusV3Script::deserialize(raw)
3291 })()
3292 .map_err(|e| e.annotate("plutus_v3_scripts"))?;
3293 plutus_v3_scripts = Some(tmp_plutus_v3_scripts);
3294 plutus_v3_scripts_key_encoding = Some(key_enc);
3295 orig_deser_order.push(7);
3296 }
3297 (unknown_key, _enc) => {
3298 return Err(
3299 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
3300 )
3301 }
3302 },
3303 cbor_event::Type::Text => {
3304 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
3305 }
3306 cbor_event::Type::Special => match len {
3307 cbor_event::LenSz::Len(_, _) => {
3308 return Err(DeserializeFailure::BreakInDefiniteLen.into())
3309 }
3310 cbor_event::LenSz::Indefinite => match raw.special()? {
3311 cbor_event::Special::Break => break,
3312 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3313 },
3314 },
3315 other_type => {
3316 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
3317 }
3318 }
3319 read += 1;
3320 }
3321 read_len.finish()?;
3322 Ok(Self {
3323 vkeywitnesses,
3324 native_scripts,
3325 bootstrap_witnesses,
3326 plutus_v1_scripts,
3327 plutus_datums,
3328 redeemers,
3329 plutus_v2_scripts,
3330 plutus_v3_scripts,
3331 encodings: Some(TransactionWitnessSetEncoding {
3332 len_encoding,
3333 orig_deser_order,
3334 vkeywitnesses_key_encoding,
3335 native_scripts_key_encoding,
3336 bootstrap_witnesses_key_encoding,
3337 plutus_v1_scripts_key_encoding,
3338 plutus_datums_key_encoding,
3339 redeemers_key_encoding,
3340 plutus_v2_scripts_key_encoding,
3341 plutus_v3_scripts_key_encoding,
3342 }),
3343 })
3344 })()
3345 .map_err(|e| e.annotate("TransactionWitnessSet"))
3346 }
3347}