1use super::cbor_encodings::*;
5use super::*;
6use cbor_event::de::Deserializer;
7use cbor_event::se::Serializer;
8use cml_chain::address::RewardAccount;
9use cml_core::error::*;
10use cml_core::serialization::*;
11use cml_crypto::Ed25519KeyHash;
12use cml_crypto::RawBytesEncoding;
13use std::io::{BufRead, Seek, SeekFrom, Write};
14
15impl Serialize for BabbageAuxiliaryData {
16 fn serialize<'se, W: Write>(
17 &self,
18 serializer: &'se mut Serializer<W>,
19 force_canonical: bool,
20 ) -> cbor_event::Result<&'se mut Serializer<W>> {
21 match self {
22 BabbageAuxiliaryData::Shelley(shelley) => {
23 shelley.serialize(serializer, force_canonical)
24 }
25 BabbageAuxiliaryData::ShelleyMA(shelley_ma) => {
26 shelley_ma.serialize(serializer, force_canonical)
27 }
28 BabbageAuxiliaryData::Babbage(babbage) => {
29 babbage.serialize(serializer, force_canonical)
30 }
31 }
32 }
33}
34
35impl Deserialize for BabbageAuxiliaryData {
36 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
37 (|| -> Result<_, DeserializeError> {
38 let initial_position = raw.as_mut_ref().stream_position().unwrap();
39 let mut errs = Vec::new();
40 let deser_variant: Result<_, DeserializeError> = ShelleyFormatAuxData::deserialize(raw);
41 match deser_variant {
42 Ok(shelley) => return Ok(Self::Shelley(shelley)),
43 Err(e) => {
44 errs.push(e.annotate("Shelley"));
45 raw.as_mut_ref()
46 .seek(SeekFrom::Start(initial_position))
47 .unwrap();
48 }
49 };
50 let deser_variant: Result<_, DeserializeError> =
51 ShelleyMAFormatAuxData::deserialize(raw);
52 match deser_variant {
53 Ok(shelley_m_a) => return Ok(Self::ShelleyMA(shelley_m_a)),
54 Err(e) => {
55 errs.push(e.annotate("ShelleyMA"));
56 raw.as_mut_ref()
57 .seek(SeekFrom::Start(initial_position))
58 .unwrap();
59 }
60 };
61 let deser_variant: Result<_, DeserializeError> = BabbageFormatAuxData::deserialize(raw);
62 match deser_variant {
63 Ok(babbage) => return Ok(Self::Babbage(babbage)),
64 Err(e) => {
65 errs.push(e.annotate("Babbage"));
66 raw.as_mut_ref()
67 .seek(SeekFrom::Start(initial_position))
68 .unwrap();
69 }
70 };
71 Err(DeserializeError::new(
72 "BabbageAuxiliaryData",
73 DeserializeFailure::NoVariantMatchedWithCauses(errs),
74 ))
75 })()
76 .map_err(|e| e.annotate("BabbageAuxiliaryData"))
77 }
78}
79
80impl Serialize for BabbageBlock {
81 fn serialize<'se, W: Write>(
82 &self,
83 serializer: &'se mut Serializer<W>,
84 force_canonical: bool,
85 ) -> cbor_event::Result<&'se mut Serializer<W>> {
86 serializer.write_array_sz(
87 self.encodings
88 .as_ref()
89 .map(|encs| encs.len_encoding)
90 .unwrap_or_default()
91 .to_len_sz(5, force_canonical),
92 )?;
93 self.header.serialize(serializer, force_canonical)?;
94 serializer.write_array_sz(
95 self.encodings
96 .as_ref()
97 .map(|encs| encs.transaction_bodies_encoding)
98 .unwrap_or_default()
99 .to_len_sz(self.transaction_bodies.len() as u64, force_canonical),
100 )?;
101 for element in self.transaction_bodies.iter() {
102 element.serialize(serializer, force_canonical)?;
103 }
104 self.encodings
105 .as_ref()
106 .map(|encs| encs.transaction_bodies_encoding)
107 .unwrap_or_default()
108 .end(serializer, force_canonical)?;
109 serializer.write_array_sz(
110 self.encodings
111 .as_ref()
112 .map(|encs| encs.transaction_witness_sets_encoding)
113 .unwrap_or_default()
114 .to_len_sz(self.transaction_witness_sets.len() as u64, force_canonical),
115 )?;
116 for element in self.transaction_witness_sets.iter() {
117 element.serialize(serializer, force_canonical)?;
118 }
119 self.encodings
120 .as_ref()
121 .map(|encs| encs.transaction_witness_sets_encoding)
122 .unwrap_or_default()
123 .end(serializer, force_canonical)?;
124 serializer.write_map_sz(
125 self.encodings
126 .as_ref()
127 .map(|encs| encs.auxiliary_data_set_encoding)
128 .unwrap_or_default()
129 .to_len_sz(self.auxiliary_data_set.len() as u64, force_canonical),
130 )?;
131 let mut key_order = self
132 .auxiliary_data_set
133 .iter()
134 .map(|(k, v)| {
135 let mut buf = cbor_event::se::Serializer::new_vec();
136 let auxiliary_data_set_key_encoding = self
137 .encodings
138 .as_ref()
139 .and_then(|encs| encs.auxiliary_data_set_key_encodings.get(k))
140 .cloned()
141 .unwrap_or_default();
142 buf.write_unsigned_integer_sz(
143 *k as u64,
144 fit_sz(*k as u64, auxiliary_data_set_key_encoding, force_canonical),
145 )?;
146 Ok((buf.finalize(), k, v))
147 })
148 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
149 if force_canonical {
150 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
151 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
152 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
153 diff_ord => diff_ord,
154 }
155 });
156 }
157 for (key_bytes, _key, value) in key_order {
158 serializer.write_raw_bytes(&key_bytes)?;
159 value.serialize(serializer, force_canonical)?;
160 }
161 self.encodings
162 .as_ref()
163 .map(|encs| encs.auxiliary_data_set_encoding)
164 .unwrap_or_default()
165 .end(serializer, force_canonical)?;
166 serializer.write_array_sz(
167 self.encodings
168 .as_ref()
169 .map(|encs| encs.invalid_transactions_encoding)
170 .unwrap_or_default()
171 .to_len_sz(self.invalid_transactions.len() as u64, force_canonical),
172 )?;
173 for (i, element) in self.invalid_transactions.iter().enumerate() {
174 let invalid_transactions_elem_encoding = self
175 .encodings
176 .as_ref()
177 .and_then(|encs| encs.invalid_transactions_elem_encodings.get(i))
178 .cloned()
179 .unwrap_or_default();
180 serializer.write_unsigned_integer_sz(
181 *element as u64,
182 fit_sz(
183 *element as u64,
184 invalid_transactions_elem_encoding,
185 force_canonical,
186 ),
187 )?;
188 }
189 self.encodings
190 .as_ref()
191 .map(|encs| encs.invalid_transactions_encoding)
192 .unwrap_or_default()
193 .end(serializer, force_canonical)?;
194 self.encodings
195 .as_ref()
196 .map(|encs| encs.len_encoding)
197 .unwrap_or_default()
198 .end(serializer, force_canonical)
199 }
200}
201
202impl Deserialize for BabbageBlock {
203 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
204 let len = raw.array_sz()?;
205 let len_encoding: LenEncoding = len.into();
206 let mut read_len = CBORReadLen::new(len);
207 read_len.read_elems(5)?;
208 read_len.finish()?;
209 (|| -> Result<_, DeserializeError> {
210 let header = Header::deserialize(raw).map_err(|e: DeserializeError| e.annotate("header"))?;
211 let (transaction_bodies, transaction_bodies_encoding) = (|| -> Result<_, DeserializeError> {
212 let mut transaction_bodies_arr = Vec::new();
213 let len = raw.array_sz()?;
214 let transaction_bodies_encoding = len.into();
215 while match len { cbor_event::LenSz::Len(n, _) => (transaction_bodies_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
216 if raw.cbor_type()? == cbor_event::Type::Special {
217 assert_eq!(raw.special()?, cbor_event::Special::Break);
218 break;
219 }
220 transaction_bodies_arr.push(BabbageTransactionBody::deserialize(raw)?);
221 }
222 Ok((transaction_bodies_arr, transaction_bodies_encoding))
223 })().map_err(|e| e.annotate("transaction_bodies"))?;
224 let (transaction_witness_sets, transaction_witness_sets_encoding) = (|| -> Result<_, DeserializeError> {
225 let mut transaction_witness_sets_arr = Vec::new();
226 let len = raw.array_sz()?;
227 let transaction_witness_sets_encoding = len.into();
228 while match len { cbor_event::LenSz::Len(n, _) => (transaction_witness_sets_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
229 if raw.cbor_type()? == cbor_event::Type::Special {
230 assert_eq!(raw.special()?, cbor_event::Special::Break);
231 break;
232 }
233 transaction_witness_sets_arr.push(BabbageTransactionWitnessSet::deserialize(raw)?);
234 }
235 Ok((transaction_witness_sets_arr, transaction_witness_sets_encoding))
236 })().map_err(|e| e.annotate("transaction_witness_sets"))?;
237 let (auxiliary_data_set, auxiliary_data_set_encoding, auxiliary_data_set_key_encodings) = (|| -> Result<_, DeserializeError> {
238 let mut auxiliary_data_set_table = OrderedHashMap::new();
239 let auxiliary_data_set_len = raw.map_sz()?;
240 let auxiliary_data_set_encoding = auxiliary_data_set_len.into();
241 let mut auxiliary_data_set_key_encodings = BTreeMap::new();
242 while match auxiliary_data_set_len { cbor_event::LenSz::Len(n, _) => (auxiliary_data_set_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
243 if raw.cbor_type()? == cbor_event::Type::Special {
244 assert_eq!(raw.special()?, cbor_event::Special::Break);
245 break;
246 }
247 let (auxiliary_data_set_key, auxiliary_data_set_key_encoding) = raw.unsigned_integer_sz().map(|(x, enc)| (x as u16, Some(enc)))?;
248 let auxiliary_data_set_value = BabbageAuxiliaryData::deserialize(raw)?;
249 if auxiliary_data_set_table.insert(auxiliary_data_set_key, auxiliary_data_set_value).is_some() {
250 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
251 }
252 auxiliary_data_set_key_encodings.insert(auxiliary_data_set_key, auxiliary_data_set_key_encoding);
253 }
254 Ok((auxiliary_data_set_table, auxiliary_data_set_encoding, auxiliary_data_set_key_encodings))
255 })().map_err(|e| e.annotate("auxiliary_data_set"))?;
256 let (invalid_transactions, invalid_transactions_encoding, invalid_transactions_elem_encodings) = (|| -> Result<_, DeserializeError> {
257 let mut invalid_transactions_arr = Vec::new();
258 let len = raw.array_sz()?;
259 let invalid_transactions_encoding = len.into();
260 let mut invalid_transactions_elem_encodings = Vec::new();
261 while match len { cbor_event::LenSz::Len(n, _) => (invalid_transactions_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
262 if raw.cbor_type()? == cbor_event::Type::Special {
263 assert_eq!(raw.special()?, cbor_event::Special::Break);
264 break;
265 }
266 let (invalid_transactions_elem, invalid_transactions_elem_encoding) = raw.unsigned_integer_sz().map(|(x, enc)| (x as u16, Some(enc)))?;
267 invalid_transactions_arr.push(invalid_transactions_elem);
268 invalid_transactions_elem_encodings.push(invalid_transactions_elem_encoding);
269 }
270 Ok((invalid_transactions_arr, invalid_transactions_encoding, invalid_transactions_elem_encodings))
271 })().map_err(|e| e.annotate("invalid_transactions"))?;
272 match len {
273 cbor_event::LenSz::Len(_, _) => (),
274 cbor_event::LenSz::Indefinite => match raw.special()? {
275 cbor_event::Special::Break => (),
276 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
277 },
278 }
279 Ok(BabbageBlock {
280 header,
281 transaction_bodies,
282 transaction_witness_sets,
283 auxiliary_data_set,
284 invalid_transactions,
285 encodings: Some(BabbageBlockEncoding {
286 len_encoding,
287 transaction_bodies_encoding,
288 transaction_witness_sets_encoding,
289 auxiliary_data_set_encoding,
290 auxiliary_data_set_key_encodings,
291 invalid_transactions_encoding,
292 invalid_transactions_elem_encodings,
293 }),
294 })
295 })().map_err(|e| e.annotate("BabbageBlock"))
296 }
297}
298
299impl Serialize for BabbageFormatAuxData {
300 fn serialize<'se, W: Write>(
301 &self,
302 serializer: &'se mut Serializer<W>,
303 force_canonical: bool,
304 ) -> cbor_event::Result<&'se mut Serializer<W>> {
305 serializer.write_tag_sz(
306 259u64,
307 fit_sz(
308 259u64,
309 self.encodings
310 .as_ref()
311 .map(|encs| encs.tag_encoding)
312 .unwrap_or_default(),
313 force_canonical,
314 ),
315 )?;
316 serializer.write_map_sz(
317 self.encodings
318 .as_ref()
319 .map(|encs| encs.len_encoding)
320 .unwrap_or_default()
321 .to_len_sz(
322 match &self.metadata {
323 Some(_) => 1,
324 None => 0,
325 } + match &self.native_scripts {
326 Some(_) => 1,
327 None => 0,
328 } + match &self.plutus_v1_scripts {
329 Some(_) => 1,
330 None => 0,
331 } + match &self.plutus_v2_scripts {
332 Some(_) => 1,
333 None => 0,
334 },
335 force_canonical,
336 ),
337 )?;
338 let deser_order = self
339 .encodings
340 .as_ref()
341 .filter(|encs| {
342 !force_canonical
343 && encs.orig_deser_order.len()
344 == match &self.metadata {
345 Some(_) => 1,
346 None => 0,
347 } + match &self.native_scripts {
348 Some(_) => 1,
349 None => 0,
350 } + match &self.plutus_v1_scripts {
351 Some(_) => 1,
352 None => 0,
353 } + match &self.plutus_v2_scripts {
354 Some(_) => 1,
355 None => 0,
356 }
357 })
358 .map(|encs| encs.orig_deser_order.clone())
359 .unwrap_or_else(|| vec![0, 1, 2, 3]);
360 for field_index in deser_order {
361 match field_index {
362 0 => {
363 if let Some(field) = &self.metadata {
364 serializer.write_unsigned_integer_sz(
365 0u64,
366 fit_sz(
367 0u64,
368 self.encodings
369 .as_ref()
370 .map(|encs| encs.metadata_key_encoding)
371 .unwrap_or_default(),
372 force_canonical,
373 ),
374 )?;
375 field.serialize(serializer, force_canonical)?;
376 }
377 }
378 1 => {
379 if let Some(field) = &self.native_scripts {
380 serializer.write_unsigned_integer_sz(
381 1u64,
382 fit_sz(
383 1u64,
384 self.encodings
385 .as_ref()
386 .map(|encs| encs.native_scripts_key_encoding)
387 .unwrap_or_default(),
388 force_canonical,
389 ),
390 )?;
391 serializer.write_array_sz(
392 self.encodings
393 .as_ref()
394 .map(|encs| encs.native_scripts_encoding)
395 .unwrap_or_default()
396 .to_len_sz(field.len() as u64, force_canonical),
397 )?;
398 for element in field.iter() {
399 element.serialize(serializer, force_canonical)?;
400 }
401 self.encodings
402 .as_ref()
403 .map(|encs| encs.native_scripts_encoding)
404 .unwrap_or_default()
405 .end(serializer, force_canonical)?;
406 }
407 }
408 2 => {
409 if let Some(field) = &self.plutus_v1_scripts {
410 serializer.write_unsigned_integer_sz(
411 2u64,
412 fit_sz(
413 2u64,
414 self.encodings
415 .as_ref()
416 .map(|encs| encs.plutus_v1_scripts_key_encoding)
417 .unwrap_or_default(),
418 force_canonical,
419 ),
420 )?;
421 serializer.write_array_sz(
422 self.encodings
423 .as_ref()
424 .map(|encs| encs.plutus_v1_scripts_encoding)
425 .unwrap_or_default()
426 .to_len_sz(field.len() as u64, force_canonical),
427 )?;
428 for element in field.iter() {
429 element.serialize(serializer, force_canonical)?;
430 }
431 self.encodings
432 .as_ref()
433 .map(|encs| encs.plutus_v1_scripts_encoding)
434 .unwrap_or_default()
435 .end(serializer, force_canonical)?;
436 }
437 }
438 3 => {
439 if let Some(field) = &self.plutus_v2_scripts {
440 serializer.write_unsigned_integer_sz(
441 3u64,
442 fit_sz(
443 3u64,
444 self.encodings
445 .as_ref()
446 .map(|encs| encs.plutus_v2_scripts_key_encoding)
447 .unwrap_or_default(),
448 force_canonical,
449 ),
450 )?;
451 serializer.write_array_sz(
452 self.encodings
453 .as_ref()
454 .map(|encs| encs.plutus_v2_scripts_encoding)
455 .unwrap_or_default()
456 .to_len_sz(field.len() as u64, force_canonical),
457 )?;
458 for element in field.iter() {
459 element.serialize(serializer, force_canonical)?;
460 }
461 self.encodings
462 .as_ref()
463 .map(|encs| encs.plutus_v2_scripts_encoding)
464 .unwrap_or_default()
465 .end(serializer, force_canonical)?;
466 }
467 }
468 _ => unreachable!(),
469 };
470 }
471 self.encodings
472 .as_ref()
473 .map(|encs| encs.len_encoding)
474 .unwrap_or_default()
475 .end(serializer, force_canonical)
476 }
477}
478
479impl Deserialize for BabbageFormatAuxData {
480 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
481 let (tag, tag_encoding) = raw.tag_sz()?;
482 if tag != 259 {
483 return Err(DeserializeError::new(
484 "BabbageFormatAuxData",
485 DeserializeFailure::TagMismatch {
486 found: tag,
487 expected: 259,
488 },
489 ));
490 }
491 let len = raw.map_sz()?;
492 let len_encoding: LenEncoding = len.into();
493 let mut read_len = CBORReadLen::new(len);
494 (|| -> Result<_, DeserializeError> {
495 let mut orig_deser_order = Vec::new();
496 let mut metadata_key_encoding = None;
497 let mut metadata = None;
498 let mut native_scripts_encoding = LenEncoding::default();
499 let mut native_scripts_key_encoding = None;
500 let mut native_scripts = None;
501 let mut plutus_v1_scripts_encoding = LenEncoding::default();
502 let mut plutus_v1_scripts_key_encoding = None;
503 let mut plutus_v1_scripts = None;
504 let mut plutus_v2_scripts_encoding = LenEncoding::default();
505 let mut plutus_v2_scripts_key_encoding = None;
506 let mut plutus_v2_scripts = None;
507 let mut read = 0;
508 while match len {
509 cbor_event::LenSz::Len(n, _) => read < n,
510 cbor_event::LenSz::Indefinite => true,
511 } {
512 match raw.cbor_type()? {
513 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
514 (0, key_enc) => {
515 if metadata.is_some() {
516 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
517 }
518 let tmp_metadata = (|| -> Result<_, DeserializeError> {
519 read_len.read_elems(1)?;
520 Metadata::deserialize(raw)
521 })()
522 .map_err(|e| e.annotate("metadata"))?;
523 metadata = Some(tmp_metadata);
524 metadata_key_encoding = Some(key_enc);
525 orig_deser_order.push(0);
526 }
527 (1, key_enc) => {
528 if native_scripts.is_some() {
529 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
530 }
531 let (tmp_native_scripts, tmp_native_scripts_encoding) =
532 (|| -> Result<_, DeserializeError> {
533 read_len.read_elems(1)?;
534 let mut native_scripts_arr = Vec::new();
535 let len = raw.array_sz()?;
536 let native_scripts_encoding = len.into();
537 while match len {
538 cbor_event::LenSz::Len(n, _) => {
539 (native_scripts_arr.len() as u64) < n
540 }
541 cbor_event::LenSz::Indefinite => true,
542 } {
543 if raw.cbor_type()? == cbor_event::Type::Special {
544 assert_eq!(raw.special()?, cbor_event::Special::Break);
545 break;
546 }
547 native_scripts_arr.push(NativeScript::deserialize(raw)?);
548 }
549 Ok((native_scripts_arr, native_scripts_encoding))
550 })()
551 .map_err(|e| e.annotate("native_scripts"))?;
552 native_scripts = Some(tmp_native_scripts);
553 native_scripts_encoding = tmp_native_scripts_encoding;
554 native_scripts_key_encoding = Some(key_enc);
555 orig_deser_order.push(1);
556 }
557 (2, key_enc) => {
558 if plutus_v1_scripts.is_some() {
559 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
560 }
561 let (tmp_plutus_v1_scripts, tmp_plutus_v1_scripts_encoding) =
562 (|| -> Result<_, DeserializeError> {
563 read_len.read_elems(1)?;
564 let mut plutus_v1_scripts_arr = Vec::new();
565 let len = raw.array_sz()?;
566 let plutus_v1_scripts_encoding = len.into();
567 while match len {
568 cbor_event::LenSz::Len(n, _) => {
569 (plutus_v1_scripts_arr.len() as u64) < n
570 }
571 cbor_event::LenSz::Indefinite => true,
572 } {
573 if raw.cbor_type()? == cbor_event::Type::Special {
574 assert_eq!(raw.special()?, cbor_event::Special::Break);
575 break;
576 }
577 plutus_v1_scripts_arr
578 .push(PlutusV1Script::deserialize(raw)?);
579 }
580 Ok((plutus_v1_scripts_arr, plutus_v1_scripts_encoding))
581 })()
582 .map_err(|e| e.annotate("plutus_v1_scripts"))?;
583 plutus_v1_scripts = Some(tmp_plutus_v1_scripts);
584 plutus_v1_scripts_encoding = tmp_plutus_v1_scripts_encoding;
585 plutus_v1_scripts_key_encoding = Some(key_enc);
586 orig_deser_order.push(2);
587 }
588 (3, key_enc) => {
589 if plutus_v2_scripts.is_some() {
590 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
591 }
592 let (tmp_plutus_v2_scripts, tmp_plutus_v2_scripts_encoding) =
593 (|| -> Result<_, DeserializeError> {
594 read_len.read_elems(1)?;
595 let mut plutus_v2_scripts_arr = Vec::new();
596 let len = raw.array_sz()?;
597 let plutus_v2_scripts_encoding = len.into();
598 while match len {
599 cbor_event::LenSz::Len(n, _) => {
600 (plutus_v2_scripts_arr.len() as u64) < n
601 }
602 cbor_event::LenSz::Indefinite => true,
603 } {
604 if raw.cbor_type()? == cbor_event::Type::Special {
605 assert_eq!(raw.special()?, cbor_event::Special::Break);
606 break;
607 }
608 plutus_v2_scripts_arr
609 .push(PlutusV2Script::deserialize(raw)?);
610 }
611 Ok((plutus_v2_scripts_arr, plutus_v2_scripts_encoding))
612 })()
613 .map_err(|e| e.annotate("plutus_v2_scripts"))?;
614 plutus_v2_scripts = Some(tmp_plutus_v2_scripts);
615 plutus_v2_scripts_encoding = tmp_plutus_v2_scripts_encoding;
616 plutus_v2_scripts_key_encoding = Some(key_enc);
617 orig_deser_order.push(3);
618 }
619 (unknown_key, _enc) => {
620 return Err(
621 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
622 )
623 }
624 },
625 cbor_event::Type::Text => {
626 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
627 }
628 cbor_event::Type::Special => match len {
629 cbor_event::LenSz::Len(_, _) => {
630 return Err(DeserializeFailure::BreakInDefiniteLen.into())
631 }
632 cbor_event::LenSz::Indefinite => match raw.special()? {
633 cbor_event::Special::Break => break,
634 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
635 },
636 },
637 other_type => {
638 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
639 }
640 }
641 read += 1;
642 }
643 read_len.finish()?;
644 Ok(Self {
645 metadata,
646 native_scripts,
647 plutus_v1_scripts,
648 plutus_v2_scripts,
649 encodings: Some(BabbageFormatAuxDataEncoding {
650 tag_encoding: Some(tag_encoding),
651 len_encoding,
652 orig_deser_order,
653 metadata_key_encoding,
654 native_scripts_key_encoding,
655 native_scripts_encoding,
656 plutus_v1_scripts_key_encoding,
657 plutus_v1_scripts_encoding,
658 plutus_v2_scripts_key_encoding,
659 plutus_v2_scripts_encoding,
660 }),
661 })
662 })()
663 .map_err(|e| e.annotate("BabbageFormatAuxData"))
664 }
665}
666
667impl Serialize for BabbageFormatTxOut {
668 fn serialize<'se, W: Write>(
669 &self,
670 serializer: &'se mut Serializer<W>,
671 force_canonical: bool,
672 ) -> cbor_event::Result<&'se mut Serializer<W>> {
673 serializer.write_map_sz(
674 self.encodings
675 .as_ref()
676 .map(|encs| encs.len_encoding)
677 .unwrap_or_default()
678 .to_len_sz(
679 2 + match &self.datum_option {
680 Some(_) => 1,
681 None => 0,
682 } + match &self.script_reference {
683 Some(_) => 1,
684 None => 0,
685 },
686 force_canonical,
687 ),
688 )?;
689 let deser_order = self
690 .encodings
691 .as_ref()
692 .filter(|encs| {
693 !force_canonical
694 && encs.orig_deser_order.len()
695 == 2 + match &self.datum_option {
696 Some(_) => 1,
697 None => 0,
698 } + match &self.script_reference {
699 Some(_) => 1,
700 None => 0,
701 }
702 })
703 .map(|encs| encs.orig_deser_order.clone())
704 .unwrap_or_else(|| vec![0, 1, 2, 3]);
705 for field_index in deser_order {
706 match field_index {
707 0 => {
708 serializer.write_unsigned_integer_sz(
709 0u64,
710 fit_sz(
711 0u64,
712 self.encodings
713 .as_ref()
714 .map(|encs| encs.address_key_encoding)
715 .unwrap_or_default(),
716 force_canonical,
717 ),
718 )?;
719 self.address.serialize(serializer, force_canonical)?;
720 }
721 1 => {
722 serializer.write_unsigned_integer_sz(
723 1u64,
724 fit_sz(
725 1u64,
726 self.encodings
727 .as_ref()
728 .map(|encs| encs.amount_key_encoding)
729 .unwrap_or_default(),
730 force_canonical,
731 ),
732 )?;
733 self.amount.serialize(serializer, force_canonical)?;
734 }
735 2 => {
736 if let Some(field) = &self.datum_option {
737 serializer.write_unsigned_integer_sz(
738 2u64,
739 fit_sz(
740 2u64,
741 self.encodings
742 .as_ref()
743 .map(|encs| encs.datum_option_key_encoding)
744 .unwrap_or_default(),
745 force_canonical,
746 ),
747 )?;
748 field.serialize(serializer, force_canonical)?;
749 }
750 }
751 3 => {
752 if let Some(field) = &self.script_reference {
753 serializer.write_unsigned_integer_sz(
754 3u64,
755 fit_sz(
756 3u64,
757 self.encodings
758 .as_ref()
759 .map(|encs| encs.script_reference_key_encoding)
760 .unwrap_or_default(),
761 force_canonical,
762 ),
763 )?;
764 serializer.write_tag_sz(
765 24u64,
766 fit_sz(
767 24u64,
768 self.encodings
769 .as_ref()
770 .map(|encs| encs.script_reference_tag_encoding)
771 .unwrap_or_default(),
772 force_canonical,
773 ),
774 )?;
775 let mut script_reference_inner_se = Serializer::new_vec();
776 field.serialize(&mut script_reference_inner_se, force_canonical)?;
777 let script_reference_bytes = script_reference_inner_se.finalize();
778 serializer.write_bytes_sz(
779 &script_reference_bytes,
780 self.encodings
781 .as_ref()
782 .map(|encs| encs.script_reference_bytes_encoding.clone())
783 .unwrap_or_default()
784 .to_str_len_sz(
785 script_reference_bytes.len() as u64,
786 force_canonical,
787 ),
788 )?;
789 }
790 }
791 _ => unreachable!(),
792 };
793 }
794 self.encodings
795 .as_ref()
796 .map(|encs| encs.len_encoding)
797 .unwrap_or_default()
798 .end(serializer, force_canonical)
799 }
800}
801
802impl Deserialize for BabbageFormatTxOut {
803 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
804 let len = raw.map_sz()?;
805 let len_encoding: LenEncoding = len.into();
806 let mut read_len = CBORReadLen::new(len);
807 read_len.read_elems(2)?;
808 (|| -> Result<_, DeserializeError> {
809 let mut orig_deser_order = Vec::new();
810 let mut address_key_encoding = None;
811 let mut address = None;
812 let mut amount_key_encoding = None;
813 let mut amount = None;
814 let mut datum_option_key_encoding = None;
815 let mut datum_option = None;
816 let mut script_reference_tag_encoding = None;
817 let mut script_reference_bytes_encoding = StringEncoding::default();
818 let mut script_reference_key_encoding = None;
819 let mut script_reference = None;
820 let mut read = 0;
821 while match len {
822 cbor_event::LenSz::Len(n, _) => read < n,
823 cbor_event::LenSz::Indefinite => true,
824 } {
825 match raw.cbor_type()? {
826 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
827 (0, key_enc) => {
828 if address.is_some() {
829 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
830 }
831 let tmp_address = Address::deserialize(raw)
832 .map_err(|e: DeserializeError| e.annotate("address"))?;
833 address = Some(tmp_address);
834 address_key_encoding = Some(key_enc);
835 orig_deser_order.push(0);
836 }
837 (1, key_enc) => {
838 if amount.is_some() {
839 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
840 }
841 let tmp_amount = Value::deserialize(raw)
842 .map_err(|e: DeserializeError| e.annotate("amount"))?;
843 amount = Some(tmp_amount);
844 amount_key_encoding = Some(key_enc);
845 orig_deser_order.push(1);
846 }
847 (2, key_enc) => {
848 if datum_option.is_some() {
849 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
850 }
851 let tmp_datum_option = (|| -> Result<_, DeserializeError> {
852 read_len.read_elems(1)?;
853 DatumOption::deserialize(raw)
854 })()
855 .map_err(|e| e.annotate("datum_option"))?;
856 datum_option = Some(tmp_datum_option);
857 datum_option_key_encoding = Some(key_enc);
858 orig_deser_order.push(2);
859 }
860 (3, key_enc) => {
861 if script_reference.is_some() {
862 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
863 }
864 let (
865 tmp_script_reference,
866 tmp_script_reference_tag_encoding,
867 tmp_script_reference_bytes_encoding,
868 ) = (|| -> Result<_, DeserializeError> {
869 read_len.read_elems(1)?;
870 match raw.tag_sz()? {
871 (24, tag_enc) => {
872 let (
873 script_reference_bytes,
874 script_reference_bytes_encoding,
875 ) = raw.bytes_sz()?;
876 let inner_de = &mut Deserializer::from(
877 std::io::Cursor::new(script_reference_bytes),
878 );
879 Ok((
880 BabbageScript::deserialize(inner_de)?,
881 Some(tag_enc),
882 StringEncoding::from(script_reference_bytes_encoding),
883 ))
884 }
885 (tag, _enc) => Err(DeserializeFailure::TagMismatch {
886 found: tag,
887 expected: 24,
888 }
889 .into()),
890 }
891 })()
892 .map_err(|e| e.annotate("script_reference"))?;
893 script_reference = Some(tmp_script_reference);
894 script_reference_tag_encoding = tmp_script_reference_tag_encoding;
895 script_reference_bytes_encoding = tmp_script_reference_bytes_encoding;
896 script_reference_key_encoding = Some(key_enc);
897 orig_deser_order.push(3);
898 }
899 (unknown_key, _enc) => {
900 return Err(
901 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
902 )
903 }
904 },
905 cbor_event::Type::Text => {
906 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
907 }
908 cbor_event::Type::Special => match len {
909 cbor_event::LenSz::Len(_, _) => {
910 return Err(DeserializeFailure::BreakInDefiniteLen.into())
911 }
912 cbor_event::LenSz::Indefinite => match raw.special()? {
913 cbor_event::Special::Break => break,
914 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
915 },
916 },
917 other_type => {
918 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
919 }
920 }
921 read += 1;
922 }
923 let address = match address {
924 Some(x) => x,
925 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(0)).into()),
926 };
927 let amount = match amount {
928 Some(x) => x,
929 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
930 };
931 read_len.finish()?;
932 Ok(Self {
933 address,
934 amount,
935 datum_option,
936 script_reference,
937 encodings: Some(BabbageFormatTxOutEncoding {
938 len_encoding,
939 orig_deser_order,
940 address_key_encoding,
941 amount_key_encoding,
942 datum_option_key_encoding,
943 script_reference_key_encoding,
944 script_reference_tag_encoding,
945 script_reference_bytes_encoding,
946 }),
947 })
948 })()
949 .map_err(|e| e.annotate("BabbageFormatTxOut"))
950 }
951}
952
953impl Serialize for BabbageProtocolParamUpdate {
954 fn serialize<'se, W: Write>(
955 &self,
956 serializer: &'se mut Serializer<W>,
957 force_canonical: bool,
958 ) -> cbor_event::Result<&'se mut Serializer<W>> {
959 serializer.write_map_sz(
960 self.encodings
961 .as_ref()
962 .map(|encs| encs.len_encoding)
963 .unwrap_or_default()
964 .to_len_sz(
965 match &self.minfee_a {
966 Some(_) => 1,
967 None => 0,
968 } + match &self.minfee_b {
969 Some(_) => 1,
970 None => 0,
971 } + match &self.max_block_body_size {
972 Some(_) => 1,
973 None => 0,
974 } + match &self.max_transaction_size {
975 Some(_) => 1,
976 None => 0,
977 } + match &self.max_block_header_size {
978 Some(_) => 1,
979 None => 0,
980 } + match &self.key_deposit {
981 Some(_) => 1,
982 None => 0,
983 } + match &self.pool_deposit {
984 Some(_) => 1,
985 None => 0,
986 } + match &self.maximum_epoch {
987 Some(_) => 1,
988 None => 0,
989 } + match &self.n_opt {
990 Some(_) => 1,
991 None => 0,
992 } + match &self.pool_pledge_influence {
993 Some(_) => 1,
994 None => 0,
995 } + match &self.expansion_rate {
996 Some(_) => 1,
997 None => 0,
998 } + match &self.treasury_growth_rate {
999 Some(_) => 1,
1000 None => 0,
1001 } + match &self.protocol_version {
1002 Some(_) => 1,
1003 None => 0,
1004 } + match &self.min_pool_cost {
1005 Some(_) => 1,
1006 None => 0,
1007 } + match &self.ada_per_utxo_byte {
1008 Some(_) => 1,
1009 None => 0,
1010 } + match &self.cost_models_for_script_languages {
1011 Some(_) => 1,
1012 None => 0,
1013 } + match &self.execution_costs {
1014 Some(_) => 1,
1015 None => 0,
1016 } + match &self.max_tx_ex_units {
1017 Some(_) => 1,
1018 None => 0,
1019 } + match &self.max_block_ex_units {
1020 Some(_) => 1,
1021 None => 0,
1022 } + match &self.max_value_size {
1023 Some(_) => 1,
1024 None => 0,
1025 } + match &self.collateral_percentage {
1026 Some(_) => 1,
1027 None => 0,
1028 } + match &self.max_collateral_inputs {
1029 Some(_) => 1,
1030 None => 0,
1031 },
1032 force_canonical,
1033 ),
1034 )?;
1035 let deser_order = self
1036 .encodings
1037 .as_ref()
1038 .filter(|encs| {
1039 !force_canonical
1040 && encs.orig_deser_order.len()
1041 == match &self.minfee_a {
1042 Some(_) => 1,
1043 None => 0,
1044 } + match &self.minfee_b {
1045 Some(_) => 1,
1046 None => 0,
1047 } + match &self.max_block_body_size {
1048 Some(_) => 1,
1049 None => 0,
1050 } + match &self.max_transaction_size {
1051 Some(_) => 1,
1052 None => 0,
1053 } + match &self.max_block_header_size {
1054 Some(_) => 1,
1055 None => 0,
1056 } + match &self.key_deposit {
1057 Some(_) => 1,
1058 None => 0,
1059 } + match &self.pool_deposit {
1060 Some(_) => 1,
1061 None => 0,
1062 } + match &self.maximum_epoch {
1063 Some(_) => 1,
1064 None => 0,
1065 } + match &self.n_opt {
1066 Some(_) => 1,
1067 None => 0,
1068 } + match &self.pool_pledge_influence {
1069 Some(_) => 1,
1070 None => 0,
1071 } + match &self.expansion_rate {
1072 Some(_) => 1,
1073 None => 0,
1074 } + match &self.treasury_growth_rate {
1075 Some(_) => 1,
1076 None => 0,
1077 } + match &self.protocol_version {
1078 Some(_) => 1,
1079 None => 0,
1080 } + match &self.min_pool_cost {
1081 Some(_) => 1,
1082 None => 0,
1083 } + match &self.ada_per_utxo_byte {
1084 Some(_) => 1,
1085 None => 0,
1086 } + match &self.cost_models_for_script_languages {
1087 Some(_) => 1,
1088 None => 0,
1089 } + match &self.execution_costs {
1090 Some(_) => 1,
1091 None => 0,
1092 } + match &self.max_tx_ex_units {
1093 Some(_) => 1,
1094 None => 0,
1095 } + match &self.max_block_ex_units {
1096 Some(_) => 1,
1097 None => 0,
1098 } + match &self.max_value_size {
1099 Some(_) => 1,
1100 None => 0,
1101 } + match &self.collateral_percentage {
1102 Some(_) => 1,
1103 None => 0,
1104 } + match &self.max_collateral_inputs {
1105 Some(_) => 1,
1106 None => 0,
1107 }
1108 })
1109 .map(|encs| encs.orig_deser_order.clone())
1110 .unwrap_or_else(|| {
1111 vec![
1112 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1113 ]
1114 });
1115 for field_index in deser_order {
1116 match field_index {
1117 0 => {
1118 if let Some(field) = &self.minfee_a {
1119 serializer.write_unsigned_integer_sz(
1120 0u64,
1121 fit_sz(
1122 0u64,
1123 self.encodings
1124 .as_ref()
1125 .map(|encs| encs.minfee_a_key_encoding)
1126 .unwrap_or_default(),
1127 force_canonical,
1128 ),
1129 )?;
1130 serializer.write_unsigned_integer_sz(
1131 *field,
1132 fit_sz(
1133 *field,
1134 self.encodings
1135 .as_ref()
1136 .map(|encs| encs.minfee_a_encoding)
1137 .unwrap_or_default(),
1138 force_canonical,
1139 ),
1140 )?;
1141 }
1142 }
1143 1 => {
1144 if let Some(field) = &self.minfee_b {
1145 serializer.write_unsigned_integer_sz(
1146 1u64,
1147 fit_sz(
1148 1u64,
1149 self.encodings
1150 .as_ref()
1151 .map(|encs| encs.minfee_b_key_encoding)
1152 .unwrap_or_default(),
1153 force_canonical,
1154 ),
1155 )?;
1156 serializer.write_unsigned_integer_sz(
1157 *field,
1158 fit_sz(
1159 *field,
1160 self.encodings
1161 .as_ref()
1162 .map(|encs| encs.minfee_b_encoding)
1163 .unwrap_or_default(),
1164 force_canonical,
1165 ),
1166 )?;
1167 }
1168 }
1169 2 => {
1170 if let Some(field) = &self.max_block_body_size {
1171 serializer.write_unsigned_integer_sz(
1172 2u64,
1173 fit_sz(
1174 2u64,
1175 self.encodings
1176 .as_ref()
1177 .map(|encs| encs.max_block_body_size_key_encoding)
1178 .unwrap_or_default(),
1179 force_canonical,
1180 ),
1181 )?;
1182 serializer.write_unsigned_integer_sz(
1183 *field,
1184 fit_sz(
1185 *field,
1186 self.encodings
1187 .as_ref()
1188 .map(|encs| encs.max_block_body_size_encoding)
1189 .unwrap_or_default(),
1190 force_canonical,
1191 ),
1192 )?;
1193 }
1194 }
1195 3 => {
1196 if let Some(field) = &self.max_transaction_size {
1197 serializer.write_unsigned_integer_sz(
1198 3u64,
1199 fit_sz(
1200 3u64,
1201 self.encodings
1202 .as_ref()
1203 .map(|encs| encs.max_transaction_size_key_encoding)
1204 .unwrap_or_default(),
1205 force_canonical,
1206 ),
1207 )?;
1208 serializer.write_unsigned_integer_sz(
1209 *field,
1210 fit_sz(
1211 *field,
1212 self.encodings
1213 .as_ref()
1214 .map(|encs| encs.max_transaction_size_encoding)
1215 .unwrap_or_default(),
1216 force_canonical,
1217 ),
1218 )?;
1219 }
1220 }
1221 4 => {
1222 if let Some(field) = &self.max_block_header_size {
1223 serializer.write_unsigned_integer_sz(
1224 4u64,
1225 fit_sz(
1226 4u64,
1227 self.encodings
1228 .as_ref()
1229 .map(|encs| encs.max_block_header_size_key_encoding)
1230 .unwrap_or_default(),
1231 force_canonical,
1232 ),
1233 )?;
1234 serializer.write_unsigned_integer_sz(
1235 *field,
1236 fit_sz(
1237 *field,
1238 self.encodings
1239 .as_ref()
1240 .map(|encs| encs.max_block_header_size_encoding)
1241 .unwrap_or_default(),
1242 force_canonical,
1243 ),
1244 )?;
1245 }
1246 }
1247 5 => {
1248 if let Some(field) = &self.key_deposit {
1249 serializer.write_unsigned_integer_sz(
1250 5u64,
1251 fit_sz(
1252 5u64,
1253 self.encodings
1254 .as_ref()
1255 .map(|encs| encs.key_deposit_key_encoding)
1256 .unwrap_or_default(),
1257 force_canonical,
1258 ),
1259 )?;
1260 serializer.write_unsigned_integer_sz(
1261 *field,
1262 fit_sz(
1263 *field,
1264 self.encodings
1265 .as_ref()
1266 .map(|encs| encs.key_deposit_encoding)
1267 .unwrap_or_default(),
1268 force_canonical,
1269 ),
1270 )?;
1271 }
1272 }
1273 6 => {
1274 if let Some(field) = &self.pool_deposit {
1275 serializer.write_unsigned_integer_sz(
1276 6u64,
1277 fit_sz(
1278 6u64,
1279 self.encodings
1280 .as_ref()
1281 .map(|encs| encs.pool_deposit_key_encoding)
1282 .unwrap_or_default(),
1283 force_canonical,
1284 ),
1285 )?;
1286 serializer.write_unsigned_integer_sz(
1287 *field,
1288 fit_sz(
1289 *field,
1290 self.encodings
1291 .as_ref()
1292 .map(|encs| encs.pool_deposit_encoding)
1293 .unwrap_or_default(),
1294 force_canonical,
1295 ),
1296 )?;
1297 }
1298 }
1299 7 => {
1300 if let Some(field) = &self.maximum_epoch {
1301 serializer.write_unsigned_integer_sz(
1302 7u64,
1303 fit_sz(
1304 7u64,
1305 self.encodings
1306 .as_ref()
1307 .map(|encs| encs.maximum_epoch_key_encoding)
1308 .unwrap_or_default(),
1309 force_canonical,
1310 ),
1311 )?;
1312 serializer.write_unsigned_integer_sz(
1313 *field,
1314 fit_sz(
1315 *field,
1316 self.encodings
1317 .as_ref()
1318 .map(|encs| encs.maximum_epoch_encoding)
1319 .unwrap_or_default(),
1320 force_canonical,
1321 ),
1322 )?;
1323 }
1324 }
1325 8 => {
1326 if let Some(field) = &self.n_opt {
1327 serializer.write_unsigned_integer_sz(
1328 8u64,
1329 fit_sz(
1330 8u64,
1331 self.encodings
1332 .as_ref()
1333 .map(|encs| encs.n_opt_key_encoding)
1334 .unwrap_or_default(),
1335 force_canonical,
1336 ),
1337 )?;
1338 serializer.write_unsigned_integer_sz(
1339 *field,
1340 fit_sz(
1341 *field,
1342 self.encodings
1343 .as_ref()
1344 .map(|encs| encs.n_opt_encoding)
1345 .unwrap_or_default(),
1346 force_canonical,
1347 ),
1348 )?;
1349 }
1350 }
1351 9 => {
1352 if let Some(field) = &self.pool_pledge_influence {
1353 serializer.write_unsigned_integer_sz(
1354 9u64,
1355 fit_sz(
1356 9u64,
1357 self.encodings
1358 .as_ref()
1359 .map(|encs| encs.pool_pledge_influence_key_encoding)
1360 .unwrap_or_default(),
1361 force_canonical,
1362 ),
1363 )?;
1364 field.serialize(serializer, force_canonical)?;
1365 }
1366 }
1367 10 => {
1368 if let Some(field) = &self.expansion_rate {
1369 serializer.write_unsigned_integer_sz(
1370 10u64,
1371 fit_sz(
1372 10u64,
1373 self.encodings
1374 .as_ref()
1375 .map(|encs| encs.expansion_rate_key_encoding)
1376 .unwrap_or_default(),
1377 force_canonical,
1378 ),
1379 )?;
1380 field.serialize(serializer, force_canonical)?;
1381 }
1382 }
1383 11 => {
1384 if let Some(field) = &self.treasury_growth_rate {
1385 serializer.write_unsigned_integer_sz(
1386 11u64,
1387 fit_sz(
1388 11u64,
1389 self.encodings
1390 .as_ref()
1391 .map(|encs| encs.treasury_growth_rate_key_encoding)
1392 .unwrap_or_default(),
1393 force_canonical,
1394 ),
1395 )?;
1396 field.serialize(serializer, force_canonical)?;
1397 }
1398 }
1399 12 => {
1400 if let Some(field) = &self.protocol_version {
1401 serializer.write_unsigned_integer_sz(
1402 14u64,
1403 fit_sz(
1404 14u64,
1405 self.encodings
1406 .as_ref()
1407 .map(|encs| encs.protocol_version_key_encoding)
1408 .unwrap_or_default(),
1409 force_canonical,
1410 ),
1411 )?;
1412 field.serialize(serializer, force_canonical)?;
1413 }
1414 }
1415 13 => {
1416 if let Some(field) = &self.min_pool_cost {
1417 serializer.write_unsigned_integer_sz(
1418 16u64,
1419 fit_sz(
1420 16u64,
1421 self.encodings
1422 .as_ref()
1423 .map(|encs| encs.min_pool_cost_key_encoding)
1424 .unwrap_or_default(),
1425 force_canonical,
1426 ),
1427 )?;
1428 serializer.write_unsigned_integer_sz(
1429 *field,
1430 fit_sz(
1431 *field,
1432 self.encodings
1433 .as_ref()
1434 .map(|encs| encs.min_pool_cost_encoding)
1435 .unwrap_or_default(),
1436 force_canonical,
1437 ),
1438 )?;
1439 }
1440 }
1441 14 => {
1442 if let Some(field) = &self.ada_per_utxo_byte {
1443 serializer.write_unsigned_integer_sz(
1444 17u64,
1445 fit_sz(
1446 17u64,
1447 self.encodings
1448 .as_ref()
1449 .map(|encs| encs.ada_per_utxo_byte_key_encoding)
1450 .unwrap_or_default(),
1451 force_canonical,
1452 ),
1453 )?;
1454 serializer.write_unsigned_integer_sz(
1455 *field,
1456 fit_sz(
1457 *field,
1458 self.encodings
1459 .as_ref()
1460 .map(|encs| encs.ada_per_utxo_byte_encoding)
1461 .unwrap_or_default(),
1462 force_canonical,
1463 ),
1464 )?;
1465 }
1466 }
1467 15 => {
1468 if let Some(field) = &self.cost_models_for_script_languages {
1469 serializer.write_unsigned_integer_sz(
1470 18u64,
1471 fit_sz(
1472 18u64,
1473 self.encodings
1474 .as_ref()
1475 .map(|encs| encs.cost_models_for_script_languages_key_encoding)
1476 .unwrap_or_default(),
1477 force_canonical,
1478 ),
1479 )?;
1480 field.serialize(serializer, force_canonical)?;
1481 }
1482 }
1483 16 => {
1484 if let Some(field) = &self.execution_costs {
1485 serializer.write_unsigned_integer_sz(
1486 19u64,
1487 fit_sz(
1488 19u64,
1489 self.encodings
1490 .as_ref()
1491 .map(|encs| encs.execution_costs_key_encoding)
1492 .unwrap_or_default(),
1493 force_canonical,
1494 ),
1495 )?;
1496 field.serialize(serializer, force_canonical)?;
1497 }
1498 }
1499 17 => {
1500 if let Some(field) = &self.max_tx_ex_units {
1501 serializer.write_unsigned_integer_sz(
1502 20u64,
1503 fit_sz(
1504 20u64,
1505 self.encodings
1506 .as_ref()
1507 .map(|encs| encs.max_tx_ex_units_key_encoding)
1508 .unwrap_or_default(),
1509 force_canonical,
1510 ),
1511 )?;
1512 field.serialize(serializer, force_canonical)?;
1513 }
1514 }
1515 18 => {
1516 if let Some(field) = &self.max_block_ex_units {
1517 serializer.write_unsigned_integer_sz(
1518 21u64,
1519 fit_sz(
1520 21u64,
1521 self.encodings
1522 .as_ref()
1523 .map(|encs| encs.max_block_ex_units_key_encoding)
1524 .unwrap_or_default(),
1525 force_canonical,
1526 ),
1527 )?;
1528 field.serialize(serializer, force_canonical)?;
1529 }
1530 }
1531 19 => {
1532 if let Some(field) = &self.max_value_size {
1533 serializer.write_unsigned_integer_sz(
1534 22u64,
1535 fit_sz(
1536 22u64,
1537 self.encodings
1538 .as_ref()
1539 .map(|encs| encs.max_value_size_key_encoding)
1540 .unwrap_or_default(),
1541 force_canonical,
1542 ),
1543 )?;
1544 serializer.write_unsigned_integer_sz(
1545 *field,
1546 fit_sz(
1547 *field,
1548 self.encodings
1549 .as_ref()
1550 .map(|encs| encs.max_value_size_encoding)
1551 .unwrap_or_default(),
1552 force_canonical,
1553 ),
1554 )?;
1555 }
1556 }
1557 20 => {
1558 if let Some(field) = &self.collateral_percentage {
1559 serializer.write_unsigned_integer_sz(
1560 23u64,
1561 fit_sz(
1562 23u64,
1563 self.encodings
1564 .as_ref()
1565 .map(|encs| encs.collateral_percentage_key_encoding)
1566 .unwrap_or_default(),
1567 force_canonical,
1568 ),
1569 )?;
1570 serializer.write_unsigned_integer_sz(
1571 *field,
1572 fit_sz(
1573 *field,
1574 self.encodings
1575 .as_ref()
1576 .map(|encs| encs.collateral_percentage_encoding)
1577 .unwrap_or_default(),
1578 force_canonical,
1579 ),
1580 )?;
1581 }
1582 }
1583 21 => {
1584 if let Some(field) = &self.max_collateral_inputs {
1585 serializer.write_unsigned_integer_sz(
1586 24u64,
1587 fit_sz(
1588 24u64,
1589 self.encodings
1590 .as_ref()
1591 .map(|encs| encs.max_collateral_inputs_key_encoding)
1592 .unwrap_or_default(),
1593 force_canonical,
1594 ),
1595 )?;
1596 serializer.write_unsigned_integer_sz(
1597 *field,
1598 fit_sz(
1599 *field,
1600 self.encodings
1601 .as_ref()
1602 .map(|encs| encs.max_collateral_inputs_encoding)
1603 .unwrap_or_default(),
1604 force_canonical,
1605 ),
1606 )?;
1607 }
1608 }
1609 _ => unreachable!(),
1610 };
1611 }
1612 self.encodings
1613 .as_ref()
1614 .map(|encs| encs.len_encoding)
1615 .unwrap_or_default()
1616 .end(serializer, force_canonical)
1617 }
1618}
1619
1620impl Deserialize for BabbageProtocolParamUpdate {
1621 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1622 let len = raw.map_sz()?;
1623 let len_encoding: LenEncoding = len.into();
1624 let mut read_len = CBORReadLen::new(len);
1625 (|| -> Result<_, DeserializeError> {
1626 let mut orig_deser_order = Vec::new();
1627 let mut minfee_a_encoding = None;
1628 let mut minfee_a_key_encoding = None;
1629 let mut minfee_a = None;
1630 let mut minfee_b_encoding = None;
1631 let mut minfee_b_key_encoding = None;
1632 let mut minfee_b = None;
1633 let mut max_block_body_size_encoding = None;
1634 let mut max_block_body_size_key_encoding = None;
1635 let mut max_block_body_size = None;
1636 let mut max_transaction_size_encoding = None;
1637 let mut max_transaction_size_key_encoding = None;
1638 let mut max_transaction_size = None;
1639 let mut max_block_header_size_encoding = None;
1640 let mut max_block_header_size_key_encoding = None;
1641 let mut max_block_header_size = None;
1642 let mut key_deposit_encoding = None;
1643 let mut key_deposit_key_encoding = None;
1644 let mut key_deposit = None;
1645 let mut pool_deposit_encoding = None;
1646 let mut pool_deposit_key_encoding = None;
1647 let mut pool_deposit = None;
1648 let mut maximum_epoch_encoding = None;
1649 let mut maximum_epoch_key_encoding = None;
1650 let mut maximum_epoch = None;
1651 let mut n_opt_encoding = None;
1652 let mut n_opt_key_encoding = None;
1653 let mut n_opt = None;
1654 let mut pool_pledge_influence_key_encoding = None;
1655 let mut pool_pledge_influence = None;
1656 let mut expansion_rate_key_encoding = None;
1657 let mut expansion_rate = None;
1658 let mut treasury_growth_rate_key_encoding = None;
1659 let mut treasury_growth_rate = None;
1660 let mut protocol_version_key_encoding = None;
1661 let mut protocol_version = None;
1662 let mut min_pool_cost_encoding = None;
1663 let mut min_pool_cost_key_encoding = None;
1664 let mut min_pool_cost = None;
1665 let mut ada_per_utxo_byte_encoding = None;
1666 let mut ada_per_utxo_byte_key_encoding = None;
1667 let mut ada_per_utxo_byte = None;
1668 let mut cost_models_for_script_languages_key_encoding = None;
1669 let mut cost_models_for_script_languages = None;
1670 let mut execution_costs_key_encoding = None;
1671 let mut execution_costs = None;
1672 let mut max_tx_ex_units_key_encoding = None;
1673 let mut max_tx_ex_units = None;
1674 let mut max_block_ex_units_key_encoding = None;
1675 let mut max_block_ex_units = None;
1676 let mut max_value_size_encoding = None;
1677 let mut max_value_size_key_encoding = None;
1678 let mut max_value_size = None;
1679 let mut collateral_percentage_encoding = None;
1680 let mut collateral_percentage_key_encoding = None;
1681 let mut collateral_percentage = None;
1682 let mut max_collateral_inputs_encoding = None;
1683 let mut max_collateral_inputs_key_encoding = None;
1684 let mut max_collateral_inputs = None;
1685 let mut read = 0;
1686 while match len {
1687 cbor_event::LenSz::Len(n, _) => read < n,
1688 cbor_event::LenSz::Indefinite => true,
1689 } {
1690 match raw.cbor_type()? {
1691 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
1692 (0, key_enc) => {
1693 if minfee_a.is_some() {
1694 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
1695 }
1696 let (tmp_minfee_a, tmp_minfee_a_encoding) =
1697 (|| -> Result<_, DeserializeError> {
1698 read_len.read_elems(1)?;
1699 raw.unsigned_integer_sz()
1700 .map_err(Into::<DeserializeError>::into)
1701 .map(|(x, enc)| (x, Some(enc)))
1702 })()
1703 .map_err(|e| e.annotate("minfee_a"))?;
1704 minfee_a = Some(tmp_minfee_a);
1705 minfee_a_encoding = tmp_minfee_a_encoding;
1706 minfee_a_key_encoding = Some(key_enc);
1707 orig_deser_order.push(0);
1708 }
1709 (1, key_enc) => {
1710 if minfee_b.is_some() {
1711 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
1712 }
1713 let (tmp_minfee_b, tmp_minfee_b_encoding) =
1714 (|| -> Result<_, DeserializeError> {
1715 read_len.read_elems(1)?;
1716 raw.unsigned_integer_sz()
1717 .map_err(Into::<DeserializeError>::into)
1718 .map(|(x, enc)| (x, Some(enc)))
1719 })()
1720 .map_err(|e| e.annotate("minfee_b"))?;
1721 minfee_b = Some(tmp_minfee_b);
1722 minfee_b_encoding = tmp_minfee_b_encoding;
1723 minfee_b_key_encoding = Some(key_enc);
1724 orig_deser_order.push(1);
1725 }
1726 (2, key_enc) => {
1727 if max_block_body_size.is_some() {
1728 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
1729 }
1730 let (tmp_max_block_body_size, tmp_max_block_body_size_encoding) =
1731 (|| -> Result<_, DeserializeError> {
1732 read_len.read_elems(1)?;
1733 raw.unsigned_integer_sz()
1734 .map_err(Into::<DeserializeError>::into)
1735 .map(|(x, enc)| (x, Some(enc)))
1736 })()
1737 .map_err(|e| e.annotate("max_block_body_size"))?;
1738 max_block_body_size = Some(tmp_max_block_body_size);
1739 max_block_body_size_encoding = tmp_max_block_body_size_encoding;
1740 max_block_body_size_key_encoding = Some(key_enc);
1741 orig_deser_order.push(2);
1742 }
1743 (3, key_enc) => {
1744 if max_transaction_size.is_some() {
1745 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
1746 }
1747 let (tmp_max_transaction_size, tmp_max_transaction_size_encoding) =
1748 (|| -> Result<_, DeserializeError> {
1749 read_len.read_elems(1)?;
1750 raw.unsigned_integer_sz()
1751 .map_err(Into::<DeserializeError>::into)
1752 .map(|(x, enc)| (x, Some(enc)))
1753 })()
1754 .map_err(|e| e.annotate("max_transaction_size"))?;
1755 max_transaction_size = Some(tmp_max_transaction_size);
1756 max_transaction_size_encoding = tmp_max_transaction_size_encoding;
1757 max_transaction_size_key_encoding = Some(key_enc);
1758 orig_deser_order.push(3);
1759 }
1760 (4, key_enc) => {
1761 if max_block_header_size.is_some() {
1762 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
1763 }
1764 let (tmp_max_block_header_size, tmp_max_block_header_size_encoding) =
1765 (|| -> Result<_, DeserializeError> {
1766 read_len.read_elems(1)?;
1767 raw.unsigned_integer_sz()
1768 .map_err(Into::<DeserializeError>::into)
1769 .map(|(x, enc)| (x, Some(enc)))
1770 })()
1771 .map_err(|e| e.annotate("max_block_header_size"))?;
1772 max_block_header_size = Some(tmp_max_block_header_size);
1773 max_block_header_size_encoding = tmp_max_block_header_size_encoding;
1774 max_block_header_size_key_encoding = Some(key_enc);
1775 orig_deser_order.push(4);
1776 }
1777 (5, key_enc) => {
1778 if key_deposit.is_some() {
1779 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
1780 }
1781 let (tmp_key_deposit, tmp_key_deposit_encoding) =
1782 (|| -> Result<_, DeserializeError> {
1783 read_len.read_elems(1)?;
1784 raw.unsigned_integer_sz()
1785 .map_err(Into::<DeserializeError>::into)
1786 .map(|(x, enc)| (x, Some(enc)))
1787 })()
1788 .map_err(|e| e.annotate("key_deposit"))?;
1789 key_deposit = Some(tmp_key_deposit);
1790 key_deposit_encoding = tmp_key_deposit_encoding;
1791 key_deposit_key_encoding = Some(key_enc);
1792 orig_deser_order.push(5);
1793 }
1794 (6, key_enc) => {
1795 if pool_deposit.is_some() {
1796 return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
1797 }
1798 let (tmp_pool_deposit, tmp_pool_deposit_encoding) =
1799 (|| -> Result<_, DeserializeError> {
1800 read_len.read_elems(1)?;
1801 raw.unsigned_integer_sz()
1802 .map_err(Into::<DeserializeError>::into)
1803 .map(|(x, enc)| (x, Some(enc)))
1804 })()
1805 .map_err(|e| e.annotate("pool_deposit"))?;
1806 pool_deposit = Some(tmp_pool_deposit);
1807 pool_deposit_encoding = tmp_pool_deposit_encoding;
1808 pool_deposit_key_encoding = Some(key_enc);
1809 orig_deser_order.push(6);
1810 }
1811 (7, key_enc) => {
1812 if maximum_epoch.is_some() {
1813 return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
1814 }
1815 let (tmp_maximum_epoch, tmp_maximum_epoch_encoding) =
1816 (|| -> Result<_, DeserializeError> {
1817 read_len.read_elems(1)?;
1818 raw.unsigned_integer_sz()
1819 .map_err(Into::<DeserializeError>::into)
1820 .map(|(x, enc)| (x, Some(enc)))
1821 })()
1822 .map_err(|e| e.annotate("maximum_epoch"))?;
1823 maximum_epoch = Some(tmp_maximum_epoch);
1824 maximum_epoch_encoding = tmp_maximum_epoch_encoding;
1825 maximum_epoch_key_encoding = Some(key_enc);
1826 orig_deser_order.push(7);
1827 }
1828 (8, key_enc) => {
1829 if n_opt.is_some() {
1830 return Err(DeserializeFailure::DuplicateKey(Key::Uint(8)).into());
1831 }
1832 let (tmp_n_opt, tmp_n_opt_encoding) =
1833 (|| -> Result<_, DeserializeError> {
1834 read_len.read_elems(1)?;
1835 raw.unsigned_integer_sz()
1836 .map_err(Into::<DeserializeError>::into)
1837 .map(|(x, enc)| (x, Some(enc)))
1838 })()
1839 .map_err(|e| e.annotate("n_opt"))?;
1840 n_opt = Some(tmp_n_opt);
1841 n_opt_encoding = tmp_n_opt_encoding;
1842 n_opt_key_encoding = Some(key_enc);
1843 orig_deser_order.push(8);
1844 }
1845 (9, key_enc) => {
1846 if pool_pledge_influence.is_some() {
1847 return Err(DeserializeFailure::DuplicateKey(Key::Uint(9)).into());
1848 }
1849 let tmp_pool_pledge_influence = (|| -> Result<_, DeserializeError> {
1850 read_len.read_elems(1)?;
1851 Rational::deserialize(raw)
1852 })()
1853 .map_err(|e| e.annotate("pool_pledge_influence"))?;
1854 pool_pledge_influence = Some(tmp_pool_pledge_influence);
1855 pool_pledge_influence_key_encoding = Some(key_enc);
1856 orig_deser_order.push(9);
1857 }
1858 (10, key_enc) => {
1859 if expansion_rate.is_some() {
1860 return Err(DeserializeFailure::DuplicateKey(Key::Uint(10)).into());
1861 }
1862 let tmp_expansion_rate = (|| -> Result<_, DeserializeError> {
1863 read_len.read_elems(1)?;
1864 UnitInterval::deserialize(raw)
1865 })()
1866 .map_err(|e| e.annotate("expansion_rate"))?;
1867 expansion_rate = Some(tmp_expansion_rate);
1868 expansion_rate_key_encoding = Some(key_enc);
1869 orig_deser_order.push(10);
1870 }
1871 (11, key_enc) => {
1872 if treasury_growth_rate.is_some() {
1873 return Err(DeserializeFailure::DuplicateKey(Key::Uint(11)).into());
1874 }
1875 let tmp_treasury_growth_rate = (|| -> Result<_, DeserializeError> {
1876 read_len.read_elems(1)?;
1877 UnitInterval::deserialize(raw)
1878 })()
1879 .map_err(|e| e.annotate("treasury_growth_rate"))?;
1880 treasury_growth_rate = Some(tmp_treasury_growth_rate);
1881 treasury_growth_rate_key_encoding = Some(key_enc);
1882 orig_deser_order.push(11);
1883 }
1884 (14, key_enc) => {
1885 if protocol_version.is_some() {
1886 return Err(DeserializeFailure::DuplicateKey(Key::Uint(14)).into());
1887 }
1888 let tmp_protocol_version = (|| -> Result<_, DeserializeError> {
1889 read_len.read_elems(1)?;
1890 ProtocolVersionStruct::deserialize(raw)
1891 })()
1892 .map_err(|e| e.annotate("protocol_version"))?;
1893 protocol_version = Some(tmp_protocol_version);
1894 protocol_version_key_encoding = Some(key_enc);
1895 orig_deser_order.push(12);
1896 }
1897 (16, key_enc) => {
1898 if min_pool_cost.is_some() {
1899 return Err(DeserializeFailure::DuplicateKey(Key::Uint(16)).into());
1900 }
1901 let (tmp_min_pool_cost, tmp_min_pool_cost_encoding) =
1902 (|| -> Result<_, DeserializeError> {
1903 read_len.read_elems(1)?;
1904 raw.unsigned_integer_sz()
1905 .map_err(Into::<DeserializeError>::into)
1906 .map(|(x, enc)| (x, Some(enc)))
1907 })()
1908 .map_err(|e| e.annotate("min_pool_cost"))?;
1909 min_pool_cost = Some(tmp_min_pool_cost);
1910 min_pool_cost_encoding = tmp_min_pool_cost_encoding;
1911 min_pool_cost_key_encoding = Some(key_enc);
1912 orig_deser_order.push(13);
1913 }
1914 (17, key_enc) => {
1915 if ada_per_utxo_byte.is_some() {
1916 return Err(DeserializeFailure::DuplicateKey(Key::Uint(17)).into());
1917 }
1918 let (tmp_ada_per_utxo_byte, tmp_ada_per_utxo_byte_encoding) =
1919 (|| -> Result<_, DeserializeError> {
1920 read_len.read_elems(1)?;
1921 raw.unsigned_integer_sz()
1922 .map_err(Into::<DeserializeError>::into)
1923 .map(|(x, enc)| (x, Some(enc)))
1924 })()
1925 .map_err(|e| e.annotate("ada_per_utxo_byte"))?;
1926 ada_per_utxo_byte = Some(tmp_ada_per_utxo_byte);
1927 ada_per_utxo_byte_encoding = tmp_ada_per_utxo_byte_encoding;
1928 ada_per_utxo_byte_key_encoding = Some(key_enc);
1929 orig_deser_order.push(14);
1930 }
1931 (18, key_enc) => {
1932 if cost_models_for_script_languages.is_some() {
1933 return Err(DeserializeFailure::DuplicateKey(Key::Uint(18)).into());
1934 }
1935 let tmp_cost_models_for_script_languages =
1936 (|| -> Result<_, DeserializeError> {
1937 read_len.read_elems(1)?;
1938 BabbageCostModels::deserialize(raw)
1939 })()
1940 .map_err(|e| e.annotate("cost_models_for_script_languages"))?;
1941 cost_models_for_script_languages =
1942 Some(tmp_cost_models_for_script_languages);
1943 cost_models_for_script_languages_key_encoding = Some(key_enc);
1944 orig_deser_order.push(15);
1945 }
1946 (19, key_enc) => {
1947 if execution_costs.is_some() {
1948 return Err(DeserializeFailure::DuplicateKey(Key::Uint(19)).into());
1949 }
1950 let tmp_execution_costs = (|| -> Result<_, DeserializeError> {
1951 read_len.read_elems(1)?;
1952 ExUnitPrices::deserialize(raw)
1953 })()
1954 .map_err(|e| e.annotate("execution_costs"))?;
1955 execution_costs = Some(tmp_execution_costs);
1956 execution_costs_key_encoding = Some(key_enc);
1957 orig_deser_order.push(16);
1958 }
1959 (20, key_enc) => {
1960 if max_tx_ex_units.is_some() {
1961 return Err(DeserializeFailure::DuplicateKey(Key::Uint(20)).into());
1962 }
1963 let tmp_max_tx_ex_units = (|| -> Result<_, DeserializeError> {
1964 read_len.read_elems(1)?;
1965 ExUnits::deserialize(raw)
1966 })()
1967 .map_err(|e| e.annotate("max_tx_ex_units"))?;
1968 max_tx_ex_units = Some(tmp_max_tx_ex_units);
1969 max_tx_ex_units_key_encoding = Some(key_enc);
1970 orig_deser_order.push(17);
1971 }
1972 (21, key_enc) => {
1973 if max_block_ex_units.is_some() {
1974 return Err(DeserializeFailure::DuplicateKey(Key::Uint(21)).into());
1975 }
1976 let tmp_max_block_ex_units = (|| -> Result<_, DeserializeError> {
1977 read_len.read_elems(1)?;
1978 ExUnits::deserialize(raw)
1979 })()
1980 .map_err(|e| e.annotate("max_block_ex_units"))?;
1981 max_block_ex_units = Some(tmp_max_block_ex_units);
1982 max_block_ex_units_key_encoding = Some(key_enc);
1983 orig_deser_order.push(18);
1984 }
1985 (22, key_enc) => {
1986 if max_value_size.is_some() {
1987 return Err(DeserializeFailure::DuplicateKey(Key::Uint(22)).into());
1988 }
1989 let (tmp_max_value_size, tmp_max_value_size_encoding) =
1990 (|| -> Result<_, DeserializeError> {
1991 read_len.read_elems(1)?;
1992 raw.unsigned_integer_sz()
1993 .map_err(Into::<DeserializeError>::into)
1994 .map(|(x, enc)| (x, Some(enc)))
1995 })()
1996 .map_err(|e| e.annotate("max_value_size"))?;
1997 max_value_size = Some(tmp_max_value_size);
1998 max_value_size_encoding = tmp_max_value_size_encoding;
1999 max_value_size_key_encoding = Some(key_enc);
2000 orig_deser_order.push(19);
2001 }
2002 (23, key_enc) => {
2003 if collateral_percentage.is_some() {
2004 return Err(DeserializeFailure::DuplicateKey(Key::Uint(23)).into());
2005 }
2006 let (tmp_collateral_percentage, tmp_collateral_percentage_encoding) =
2007 (|| -> Result<_, DeserializeError> {
2008 read_len.read_elems(1)?;
2009 raw.unsigned_integer_sz()
2010 .map_err(Into::<DeserializeError>::into)
2011 .map(|(x, enc)| (x, Some(enc)))
2012 })()
2013 .map_err(|e| e.annotate("collateral_percentage"))?;
2014 collateral_percentage = Some(tmp_collateral_percentage);
2015 collateral_percentage_encoding = tmp_collateral_percentage_encoding;
2016 collateral_percentage_key_encoding = Some(key_enc);
2017 orig_deser_order.push(20);
2018 }
2019 (24, key_enc) => {
2020 if max_collateral_inputs.is_some() {
2021 return Err(DeserializeFailure::DuplicateKey(Key::Uint(24)).into());
2022 }
2023 let (tmp_max_collateral_inputs, tmp_max_collateral_inputs_encoding) =
2024 (|| -> Result<_, DeserializeError> {
2025 read_len.read_elems(1)?;
2026 raw.unsigned_integer_sz()
2027 .map_err(Into::<DeserializeError>::into)
2028 .map(|(x, enc)| (x, Some(enc)))
2029 })()
2030 .map_err(|e| e.annotate("max_collateral_inputs"))?;
2031 max_collateral_inputs = Some(tmp_max_collateral_inputs);
2032 max_collateral_inputs_encoding = tmp_max_collateral_inputs_encoding;
2033 max_collateral_inputs_key_encoding = Some(key_enc);
2034 orig_deser_order.push(21);
2035 }
2036 (unknown_key, _enc) => {
2037 return Err(
2038 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
2039 )
2040 }
2041 },
2042 cbor_event::Type::Text => {
2043 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
2044 }
2045 cbor_event::Type::Special => match len {
2046 cbor_event::LenSz::Len(_, _) => {
2047 return Err(DeserializeFailure::BreakInDefiniteLen.into())
2048 }
2049 cbor_event::LenSz::Indefinite => match raw.special()? {
2050 cbor_event::Special::Break => break,
2051 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2052 },
2053 },
2054 other_type => {
2055 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
2056 }
2057 }
2058 read += 1;
2059 }
2060 read_len.finish()?;
2061 Ok(Self {
2062 minfee_a,
2063 minfee_b,
2064 max_block_body_size,
2065 max_transaction_size,
2066 max_block_header_size,
2067 key_deposit,
2068 pool_deposit,
2069 maximum_epoch,
2070 n_opt,
2071 pool_pledge_influence,
2072 expansion_rate,
2073 treasury_growth_rate,
2074 protocol_version,
2075 min_pool_cost,
2076 ada_per_utxo_byte,
2077 cost_models_for_script_languages,
2078 execution_costs,
2079 max_tx_ex_units,
2080 max_block_ex_units,
2081 max_value_size,
2082 collateral_percentage,
2083 max_collateral_inputs,
2084 encodings: Some(BabbageProtocolParamUpdateEncoding {
2085 len_encoding,
2086 orig_deser_order,
2087 minfee_a_key_encoding,
2088 minfee_a_encoding,
2089 minfee_b_key_encoding,
2090 minfee_b_encoding,
2091 max_block_body_size_key_encoding,
2092 max_block_body_size_encoding,
2093 max_transaction_size_key_encoding,
2094 max_transaction_size_encoding,
2095 max_block_header_size_key_encoding,
2096 max_block_header_size_encoding,
2097 key_deposit_key_encoding,
2098 key_deposit_encoding,
2099 pool_deposit_key_encoding,
2100 pool_deposit_encoding,
2101 maximum_epoch_key_encoding,
2102 maximum_epoch_encoding,
2103 n_opt_key_encoding,
2104 n_opt_encoding,
2105 pool_pledge_influence_key_encoding,
2106 expansion_rate_key_encoding,
2107 treasury_growth_rate_key_encoding,
2108 protocol_version_key_encoding,
2109 min_pool_cost_key_encoding,
2110 min_pool_cost_encoding,
2111 ada_per_utxo_byte_key_encoding,
2112 ada_per_utxo_byte_encoding,
2113 cost_models_for_script_languages_key_encoding,
2114 execution_costs_key_encoding,
2115 max_tx_ex_units_key_encoding,
2116 max_block_ex_units_key_encoding,
2117 max_value_size_key_encoding,
2118 max_value_size_encoding,
2119 collateral_percentage_key_encoding,
2120 collateral_percentage_encoding,
2121 max_collateral_inputs_key_encoding,
2122 max_collateral_inputs_encoding,
2123 }),
2124 })
2125 })()
2126 .map_err(|e| e.annotate("BabbageProtocolParamUpdate"))
2127 }
2128}
2129
2130impl Serialize for BabbageScript {
2131 fn serialize<'se, W: Write>(
2132 &self,
2133 serializer: &'se mut Serializer<W>,
2134 force_canonical: bool,
2135 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2136 match self {
2137 BabbageScript::Native {
2138 script,
2139 len_encoding,
2140 tag_encoding,
2141 } => {
2142 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
2143 serializer.write_unsigned_integer_sz(
2144 0u64,
2145 fit_sz(0u64, *tag_encoding, force_canonical),
2146 )?;
2147 script.serialize(serializer, force_canonical)?;
2148 len_encoding.end(serializer, force_canonical)?;
2149 Ok(serializer)
2150 }
2151 BabbageScript::PlutusV1 {
2152 script,
2153 len_encoding,
2154 tag_encoding,
2155 } => {
2156 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
2157 serializer.write_unsigned_integer_sz(
2158 1u64,
2159 fit_sz(1u64, *tag_encoding, force_canonical),
2160 )?;
2161 script.serialize(serializer, force_canonical)?;
2162 len_encoding.end(serializer, force_canonical)?;
2163 Ok(serializer)
2164 }
2165 BabbageScript::PlutusV2 {
2166 script,
2167 len_encoding,
2168 tag_encoding,
2169 } => {
2170 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
2171 serializer.write_unsigned_integer_sz(
2172 2u64,
2173 fit_sz(2u64, *tag_encoding, force_canonical),
2174 )?;
2175 script.serialize(serializer, force_canonical)?;
2176 len_encoding.end(serializer, force_canonical)?;
2177 Ok(serializer)
2178 }
2179 }
2180 }
2181}
2182
2183impl Deserialize for BabbageScript {
2184 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2185 (|| -> Result<_, DeserializeError> {
2186 let len = raw.array_sz()?;
2187 let len_encoding: LenEncoding = len.into();
2188 let initial_position = raw.as_mut_ref().stream_position().unwrap();
2189 let mut errs = Vec::new();
2190 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
2191 let mut read_len = CBORReadLen::new(len);
2192 read_len.read_elems(2)?;
2193 read_len.finish()?;
2194 let tag_encoding = (|| -> Result<_, DeserializeError> {
2195 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2196 if tag_value != 0 {
2197 return Err(DeserializeFailure::FixedValueMismatch {
2198 found: Key::Uint(tag_value),
2199 expected: Key::Uint(0),
2200 }
2201 .into());
2202 }
2203 Ok(Some(tag_encoding))
2204 })()
2205 .map_err(|e| e.annotate("tag"))?;
2206 let script = NativeScript::deserialize(raw)
2207 .map_err(|e: DeserializeError| e.annotate("script"))?;
2208 match len {
2209 cbor_event::LenSz::Len(_, _) => (),
2210 cbor_event::LenSz::Indefinite => match raw.special()? {
2211 cbor_event::Special::Break => (),
2212 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2213 },
2214 }
2215 Ok(Self::Native {
2216 script,
2217 len_encoding,
2218 tag_encoding,
2219 })
2220 })(raw);
2221 match variant_deser {
2222 Ok(variant) => return Ok(variant),
2223 Err(e) => {
2224 errs.push(e.annotate("Native"));
2225 raw.as_mut_ref()
2226 .seek(SeekFrom::Start(initial_position))
2227 .unwrap();
2228 }
2229 };
2230 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
2231 let mut read_len = CBORReadLen::new(len);
2232 read_len.read_elems(2)?;
2233 read_len.finish()?;
2234 let tag_encoding = (|| -> Result<_, DeserializeError> {
2235 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2236 if tag_value != 1 {
2237 return Err(DeserializeFailure::FixedValueMismatch {
2238 found: Key::Uint(tag_value),
2239 expected: Key::Uint(1),
2240 }
2241 .into());
2242 }
2243 Ok(Some(tag_encoding))
2244 })()
2245 .map_err(|e| e.annotate("tag"))?;
2246 let script = PlutusV1Script::deserialize(raw)
2247 .map_err(|e: DeserializeError| e.annotate("script"))?;
2248 match len {
2249 cbor_event::LenSz::Len(_, _) => (),
2250 cbor_event::LenSz::Indefinite => match raw.special()? {
2251 cbor_event::Special::Break => (),
2252 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2253 },
2254 }
2255 Ok(Self::PlutusV1 {
2256 script,
2257 len_encoding,
2258 tag_encoding,
2259 })
2260 })(raw);
2261 match variant_deser {
2262 Ok(variant) => return Ok(variant),
2263 Err(e) => {
2264 errs.push(e.annotate("PlutusV1"));
2265 raw.as_mut_ref()
2266 .seek(SeekFrom::Start(initial_position))
2267 .unwrap();
2268 }
2269 };
2270 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
2271 let mut read_len = CBORReadLen::new(len);
2272 read_len.read_elems(2)?;
2273 read_len.finish()?;
2274 let tag_encoding = (|| -> Result<_, DeserializeError> {
2275 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2276 if tag_value != 2 {
2277 return Err(DeserializeFailure::FixedValueMismatch {
2278 found: Key::Uint(tag_value),
2279 expected: Key::Uint(2),
2280 }
2281 .into());
2282 }
2283 Ok(Some(tag_encoding))
2284 })()
2285 .map_err(|e| e.annotate("tag"))?;
2286 let script = PlutusV2Script::deserialize(raw)
2287 .map_err(|e: DeserializeError| e.annotate("script"))?;
2288 match len {
2289 cbor_event::LenSz::Len(_, _) => (),
2290 cbor_event::LenSz::Indefinite => match raw.special()? {
2291 cbor_event::Special::Break => (),
2292 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2293 },
2294 }
2295 Ok(Self::PlutusV2 {
2296 script,
2297 len_encoding,
2298 tag_encoding,
2299 })
2300 })(raw);
2301 match variant_deser {
2302 Ok(variant) => return Ok(variant),
2303 Err(e) => {
2304 errs.push(e.annotate("PlutusV2"));
2305 raw.as_mut_ref()
2306 .seek(SeekFrom::Start(initial_position))
2307 .unwrap();
2308 }
2309 };
2310 Err(DeserializeError::new(
2311 "BabbageScript",
2312 DeserializeFailure::NoVariantMatchedWithCauses(errs),
2313 ))
2314 })()
2315 .map_err(|e| e.annotate("BabbageScript"))
2316 }
2317}
2318
2319impl Serialize for BabbageTransaction {
2320 fn serialize<'se, W: Write>(
2321 &self,
2322 serializer: &'se mut Serializer<W>,
2323 force_canonical: bool,
2324 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2325 serializer.write_array_sz(
2326 self.encodings
2327 .as_ref()
2328 .map(|encs| encs.len_encoding)
2329 .unwrap_or_default()
2330 .to_len_sz(4, force_canonical),
2331 )?;
2332 self.body.serialize(serializer, force_canonical)?;
2333 self.witness_set.serialize(serializer, force_canonical)?;
2334 serializer.write_special(cbor_event::Special::Bool(self.is_valid))?;
2335 match &self.auxiliary_data {
2336 Some(x) => x.serialize(serializer, force_canonical),
2337 None => serializer.write_special(cbor_event::Special::Null),
2338 }?;
2339 self.encodings
2340 .as_ref()
2341 .map(|encs| encs.len_encoding)
2342 .unwrap_or_default()
2343 .end(serializer, force_canonical)
2344 }
2345}
2346
2347impl Deserialize for BabbageTransaction {
2348 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2349 let len = raw.array_sz()?;
2350 let len_encoding: LenEncoding = len.into();
2351 let mut read_len = CBORReadLen::new(len);
2352 read_len.read_elems(4)?;
2353 read_len.finish()?;
2354 (|| -> Result<_, DeserializeError> {
2355 let body = BabbageTransactionBody::deserialize(raw)
2356 .map_err(|e: DeserializeError| e.annotate("body"))?;
2357 let witness_set = BabbageTransactionWitnessSet::deserialize(raw)
2358 .map_err(|e: DeserializeError| e.annotate("witness_set"))?;
2359 let is_valid = raw
2360 .bool()
2361 .map_err(Into::into)
2362 .map_err(|e: DeserializeError| e.annotate("is_valid"))?;
2363 let auxiliary_data = (|| -> Result<_, DeserializeError> {
2364 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
2365 true => Some(BabbageAuxiliaryData::deserialize(raw)?),
2366 false => {
2367 if raw.special()? != cbor_event::Special::Null {
2368 return Err(DeserializeFailure::ExpectedNull.into());
2369 }
2370 None
2371 }
2372 })
2373 })()
2374 .map_err(|e| e.annotate("auxiliary_data"))?;
2375 match len {
2376 cbor_event::LenSz::Len(_, _) => (),
2377 cbor_event::LenSz::Indefinite => match raw.special()? {
2378 cbor_event::Special::Break => (),
2379 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2380 },
2381 }
2382 Ok(BabbageTransaction {
2383 body,
2384 witness_set,
2385 is_valid,
2386 auxiliary_data,
2387 encodings: Some(BabbageTransactionEncoding { len_encoding }),
2388 })
2389 })()
2390 .map_err(|e| e.annotate("BabbageTransaction"))
2391 }
2392}
2393
2394impl Serialize for BabbageTransactionBody {
2395 fn serialize<'se, W: Write>(
2396 &self,
2397 serializer: &'se mut Serializer<W>,
2398 force_canonical: bool,
2399 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2400 serializer.write_map_sz(
2401 self.encodings
2402 .as_ref()
2403 .map(|encs| encs.len_encoding)
2404 .unwrap_or_default()
2405 .to_len_sz(
2406 3 + match &self.ttl {
2407 Some(_) => 1,
2408 None => 0,
2409 } + match &self.certs {
2410 Some(_) => 1,
2411 None => 0,
2412 } + match &self.withdrawals {
2413 Some(_) => 1,
2414 None => 0,
2415 } + match &self.update {
2416 Some(_) => 1,
2417 None => 0,
2418 } + match &self.auxiliary_data_hash {
2419 Some(_) => 1,
2420 None => 0,
2421 } + match &self.validity_interval_start {
2422 Some(_) => 1,
2423 None => 0,
2424 } + match &self.mint {
2425 Some(_) => 1,
2426 None => 0,
2427 } + match &self.script_data_hash {
2428 Some(_) => 1,
2429 None => 0,
2430 } + match &self.collateral_inputs {
2431 Some(_) => 1,
2432 None => 0,
2433 } + match &self.required_signers {
2434 Some(_) => 1,
2435 None => 0,
2436 } + match &self.network_id {
2437 Some(_) => 1,
2438 None => 0,
2439 } + match &self.collateral_return {
2440 Some(_) => 1,
2441 None => 0,
2442 } + match &self.total_collateral {
2443 Some(_) => 1,
2444 None => 0,
2445 } + match &self.reference_inputs {
2446 Some(_) => 1,
2447 None => 0,
2448 },
2449 force_canonical,
2450 ),
2451 )?;
2452 let deser_order = self
2453 .encodings
2454 .as_ref()
2455 .filter(|encs| {
2456 !force_canonical
2457 && encs.orig_deser_order.len()
2458 == 3 + match &self.ttl {
2459 Some(_) => 1,
2460 None => 0,
2461 } + match &self.certs {
2462 Some(_) => 1,
2463 None => 0,
2464 } + match &self.withdrawals {
2465 Some(_) => 1,
2466 None => 0,
2467 } + match &self.update {
2468 Some(_) => 1,
2469 None => 0,
2470 } + match &self.auxiliary_data_hash {
2471 Some(_) => 1,
2472 None => 0,
2473 } + match &self.validity_interval_start {
2474 Some(_) => 1,
2475 None => 0,
2476 } + match &self.mint {
2477 Some(_) => 1,
2478 None => 0,
2479 } + match &self.script_data_hash {
2480 Some(_) => 1,
2481 None => 0,
2482 } + match &self.collateral_inputs {
2483 Some(_) => 1,
2484 None => 0,
2485 } + match &self.required_signers {
2486 Some(_) => 1,
2487 None => 0,
2488 } + match &self.network_id {
2489 Some(_) => 1,
2490 None => 0,
2491 } + match &self.collateral_return {
2492 Some(_) => 1,
2493 None => 0,
2494 } + match &self.total_collateral {
2495 Some(_) => 1,
2496 None => 0,
2497 } + match &self.reference_inputs {
2498 Some(_) => 1,
2499 None => 0,
2500 }
2501 })
2502 .map(|encs| encs.orig_deser_order.clone())
2503 .unwrap_or_else(|| vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
2504 for field_index in deser_order {
2505 match field_index {
2506 0 => {
2507 serializer.write_unsigned_integer_sz(
2508 0u64,
2509 fit_sz(
2510 0u64,
2511 self.encodings
2512 .as_ref()
2513 .map(|encs| encs.inputs_key_encoding)
2514 .unwrap_or_default(),
2515 force_canonical,
2516 ),
2517 )?;
2518 serializer.write_array_sz(
2519 self.encodings
2520 .as_ref()
2521 .map(|encs| encs.inputs_encoding)
2522 .unwrap_or_default()
2523 .to_len_sz(self.inputs.len() as u64, force_canonical),
2524 )?;
2525 for element in self.inputs.iter() {
2526 element.serialize(serializer, force_canonical)?;
2527 }
2528 self.encodings
2529 .as_ref()
2530 .map(|encs| encs.inputs_encoding)
2531 .unwrap_or_default()
2532 .end(serializer, force_canonical)?;
2533 }
2534 1 => {
2535 serializer.write_unsigned_integer_sz(
2536 1u64,
2537 fit_sz(
2538 1u64,
2539 self.encodings
2540 .as_ref()
2541 .map(|encs| encs.outputs_key_encoding)
2542 .unwrap_or_default(),
2543 force_canonical,
2544 ),
2545 )?;
2546 serializer.write_array_sz(
2547 self.encodings
2548 .as_ref()
2549 .map(|encs| encs.outputs_encoding)
2550 .unwrap_or_default()
2551 .to_len_sz(self.outputs.len() as u64, force_canonical),
2552 )?;
2553 for element in self.outputs.iter() {
2554 element.serialize(serializer, force_canonical)?;
2555 }
2556 self.encodings
2557 .as_ref()
2558 .map(|encs| encs.outputs_encoding)
2559 .unwrap_or_default()
2560 .end(serializer, force_canonical)?;
2561 }
2562 2 => {
2563 serializer.write_unsigned_integer_sz(
2564 2u64,
2565 fit_sz(
2566 2u64,
2567 self.encodings
2568 .as_ref()
2569 .map(|encs| encs.fee_key_encoding)
2570 .unwrap_or_default(),
2571 force_canonical,
2572 ),
2573 )?;
2574 serializer.write_unsigned_integer_sz(
2575 self.fee,
2576 fit_sz(
2577 self.fee,
2578 self.encodings
2579 .as_ref()
2580 .map(|encs| encs.fee_encoding)
2581 .unwrap_or_default(),
2582 force_canonical,
2583 ),
2584 )?;
2585 }
2586 3 => {
2587 if let Some(field) = &self.ttl {
2588 serializer.write_unsigned_integer_sz(
2589 3u64,
2590 fit_sz(
2591 3u64,
2592 self.encodings
2593 .as_ref()
2594 .map(|encs| encs.ttl_key_encoding)
2595 .unwrap_or_default(),
2596 force_canonical,
2597 ),
2598 )?;
2599 serializer.write_unsigned_integer_sz(
2600 *field,
2601 fit_sz(
2602 *field,
2603 self.encodings
2604 .as_ref()
2605 .map(|encs| encs.ttl_encoding)
2606 .unwrap_or_default(),
2607 force_canonical,
2608 ),
2609 )?;
2610 }
2611 }
2612 4 => {
2613 if let Some(field) = &self.certs {
2614 serializer.write_unsigned_integer_sz(
2615 4u64,
2616 fit_sz(
2617 4u64,
2618 self.encodings
2619 .as_ref()
2620 .map(|encs| encs.certs_key_encoding)
2621 .unwrap_or_default(),
2622 force_canonical,
2623 ),
2624 )?;
2625 serializer.write_array_sz(
2626 self.encodings
2627 .as_ref()
2628 .map(|encs| encs.certs_encoding)
2629 .unwrap_or_default()
2630 .to_len_sz(field.len() as u64, force_canonical),
2631 )?;
2632 for element in field.iter() {
2633 element.serialize(serializer, force_canonical)?;
2634 }
2635 self.encodings
2636 .as_ref()
2637 .map(|encs| encs.certs_encoding)
2638 .unwrap_or_default()
2639 .end(serializer, force_canonical)?;
2640 }
2641 }
2642 5 => {
2643 if let Some(field) = &self.withdrawals {
2644 serializer.write_unsigned_integer_sz(
2645 5u64,
2646 fit_sz(
2647 5u64,
2648 self.encodings
2649 .as_ref()
2650 .map(|encs| encs.withdrawals_key_encoding)
2651 .unwrap_or_default(),
2652 force_canonical,
2653 ),
2654 )?;
2655 serializer.write_map_sz(
2656 self.encodings
2657 .as_ref()
2658 .map(|encs| encs.withdrawals_encoding)
2659 .unwrap_or_default()
2660 .to_len_sz(field.len() as u64, force_canonical),
2661 )?;
2662 let mut key_order = field
2663 .iter()
2664 .map(|(k, v)| {
2665 let mut buf = cbor_event::se::Serializer::new_vec();
2666 k.serialize(&mut buf, force_canonical)?;
2667 Ok((buf.finalize(), k, v))
2668 })
2669 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
2670 if force_canonical {
2671 key_order.sort_by(
2672 |(lhs_bytes, _, _), (rhs_bytes, _, _)| match lhs_bytes
2673 .len()
2674 .cmp(&rhs_bytes.len())
2675 {
2676 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
2677 diff_ord => diff_ord,
2678 },
2679 );
2680 }
2681 for (key_bytes, key, value) in key_order {
2682 serializer.write_raw_bytes(&key_bytes)?;
2683 let withdrawals_value_encoding = self
2684 .encodings
2685 .as_ref()
2686 .and_then(|encs| encs.withdrawals_value_encodings.get(key))
2687 .cloned()
2688 .unwrap_or_default();
2689 serializer.write_unsigned_integer_sz(
2690 *value,
2691 fit_sz(*value, withdrawals_value_encoding, force_canonical),
2692 )?;
2693 }
2694 self.encodings
2695 .as_ref()
2696 .map(|encs| encs.withdrawals_encoding)
2697 .unwrap_or_default()
2698 .end(serializer, force_canonical)?;
2699 }
2700 }
2701 6 => {
2702 if let Some(field) = &self.update {
2703 serializer.write_unsigned_integer_sz(
2704 6u64,
2705 fit_sz(
2706 6u64,
2707 self.encodings
2708 .as_ref()
2709 .map(|encs| encs.update_key_encoding)
2710 .unwrap_or_default(),
2711 force_canonical,
2712 ),
2713 )?;
2714 field.serialize(serializer, force_canonical)?;
2715 }
2716 }
2717 7 => {
2718 if let Some(field) = &self.auxiliary_data_hash {
2719 serializer.write_unsigned_integer_sz(
2720 7u64,
2721 fit_sz(
2722 7u64,
2723 self.encodings
2724 .as_ref()
2725 .map(|encs| encs.auxiliary_data_hash_key_encoding)
2726 .unwrap_or_default(),
2727 force_canonical,
2728 ),
2729 )?;
2730 serializer.write_bytes_sz(
2731 field.to_raw_bytes(),
2732 self.encodings
2733 .as_ref()
2734 .map(|encs| encs.auxiliary_data_hash_encoding.clone())
2735 .unwrap_or_default()
2736 .to_str_len_sz(field.to_raw_bytes().len() as u64, force_canonical),
2737 )?;
2738 }
2739 }
2740 8 => {
2741 if let Some(field) = &self.validity_interval_start {
2742 serializer.write_unsigned_integer_sz(
2743 8u64,
2744 fit_sz(
2745 8u64,
2746 self.encodings
2747 .as_ref()
2748 .map(|encs| encs.validity_interval_start_key_encoding)
2749 .unwrap_or_default(),
2750 force_canonical,
2751 ),
2752 )?;
2753 serializer.write_unsigned_integer_sz(
2754 *field,
2755 fit_sz(
2756 *field,
2757 self.encodings
2758 .as_ref()
2759 .map(|encs| encs.validity_interval_start_encoding)
2760 .unwrap_or_default(),
2761 force_canonical,
2762 ),
2763 )?;
2764 }
2765 }
2766 9 => {
2767 if let Some(field) = &self.mint {
2768 serializer.write_unsigned_integer_sz(
2769 9u64,
2770 fit_sz(
2771 9u64,
2772 self.encodings
2773 .as_ref()
2774 .map(|encs| encs.mint_key_encoding)
2775 .unwrap_or_default(),
2776 force_canonical,
2777 ),
2778 )?;
2779 field.serialize(serializer, force_canonical)?;
2780 }
2781 }
2782 10 => {
2783 if let Some(field) = &self.script_data_hash {
2784 serializer.write_unsigned_integer_sz(
2785 11u64,
2786 fit_sz(
2787 11u64,
2788 self.encodings
2789 .as_ref()
2790 .map(|encs| encs.script_data_hash_key_encoding)
2791 .unwrap_or_default(),
2792 force_canonical,
2793 ),
2794 )?;
2795 serializer.write_bytes_sz(
2796 field.to_raw_bytes(),
2797 self.encodings
2798 .as_ref()
2799 .map(|encs| encs.script_data_hash_encoding.clone())
2800 .unwrap_or_default()
2801 .to_str_len_sz(field.to_raw_bytes().len() as u64, force_canonical),
2802 )?;
2803 }
2804 }
2805 11 => {
2806 if let Some(field) = &self.collateral_inputs {
2807 serializer.write_unsigned_integer_sz(
2808 13u64,
2809 fit_sz(
2810 13u64,
2811 self.encodings
2812 .as_ref()
2813 .map(|encs| encs.collateral_inputs_key_encoding)
2814 .unwrap_or_default(),
2815 force_canonical,
2816 ),
2817 )?;
2818 serializer.write_array_sz(
2819 self.encodings
2820 .as_ref()
2821 .map(|encs| encs.collateral_inputs_encoding)
2822 .unwrap_or_default()
2823 .to_len_sz(field.len() as u64, force_canonical),
2824 )?;
2825 for element in field.iter() {
2826 element.serialize(serializer, force_canonical)?;
2827 }
2828 self.encodings
2829 .as_ref()
2830 .map(|encs| encs.collateral_inputs_encoding)
2831 .unwrap_or_default()
2832 .end(serializer, force_canonical)?;
2833 }
2834 }
2835 12 => {
2836 if let Some(field) = &self.required_signers {
2837 serializer.write_unsigned_integer_sz(
2838 14u64,
2839 fit_sz(
2840 14u64,
2841 self.encodings
2842 .as_ref()
2843 .map(|encs| encs.required_signers_key_encoding)
2844 .unwrap_or_default(),
2845 force_canonical,
2846 ),
2847 )?;
2848 serializer.write_array_sz(
2849 self.encodings
2850 .as_ref()
2851 .map(|encs| encs.required_signers_encoding)
2852 .unwrap_or_default()
2853 .to_len_sz(field.len() as u64, force_canonical),
2854 )?;
2855 for (i, element) in field.iter().enumerate() {
2856 let required_signers_elem_encoding = self
2857 .encodings
2858 .as_ref()
2859 .and_then(|encs| encs.required_signers_elem_encodings.get(i))
2860 .cloned()
2861 .unwrap_or_default();
2862 serializer.write_bytes_sz(
2863 element.to_raw_bytes(),
2864 required_signers_elem_encoding.to_str_len_sz(
2865 element.to_raw_bytes().len() as u64,
2866 force_canonical,
2867 ),
2868 )?;
2869 }
2870 self.encodings
2871 .as_ref()
2872 .map(|encs| encs.required_signers_encoding)
2873 .unwrap_or_default()
2874 .end(serializer, force_canonical)?;
2875 }
2876 }
2877 13 => {
2878 if let Some(field) = &self.network_id {
2879 serializer.write_unsigned_integer_sz(
2880 15u64,
2881 fit_sz(
2882 15u64,
2883 self.encodings
2884 .as_ref()
2885 .map(|encs| encs.network_id_key_encoding)
2886 .unwrap_or_default(),
2887 force_canonical,
2888 ),
2889 )?;
2890 field.serialize(serializer, force_canonical)?;
2891 }
2892 }
2893 14 => {
2894 if let Some(field) = &self.collateral_return {
2895 serializer.write_unsigned_integer_sz(
2896 16u64,
2897 fit_sz(
2898 16u64,
2899 self.encodings
2900 .as_ref()
2901 .map(|encs| encs.collateral_return_key_encoding)
2902 .unwrap_or_default(),
2903 force_canonical,
2904 ),
2905 )?;
2906 field.serialize(serializer, force_canonical)?;
2907 }
2908 }
2909 15 => {
2910 if let Some(field) = &self.total_collateral {
2911 serializer.write_unsigned_integer_sz(
2912 17u64,
2913 fit_sz(
2914 17u64,
2915 self.encodings
2916 .as_ref()
2917 .map(|encs| encs.total_collateral_key_encoding)
2918 .unwrap_or_default(),
2919 force_canonical,
2920 ),
2921 )?;
2922 serializer.write_unsigned_integer_sz(
2923 *field,
2924 fit_sz(
2925 *field,
2926 self.encodings
2927 .as_ref()
2928 .map(|encs| encs.total_collateral_encoding)
2929 .unwrap_or_default(),
2930 force_canonical,
2931 ),
2932 )?;
2933 }
2934 }
2935 16 => {
2936 if let Some(field) = &self.reference_inputs {
2937 serializer.write_unsigned_integer_sz(
2938 18u64,
2939 fit_sz(
2940 18u64,
2941 self.encodings
2942 .as_ref()
2943 .map(|encs| encs.reference_inputs_key_encoding)
2944 .unwrap_or_default(),
2945 force_canonical,
2946 ),
2947 )?;
2948 serializer.write_array_sz(
2949 self.encodings
2950 .as_ref()
2951 .map(|encs| encs.reference_inputs_encoding)
2952 .unwrap_or_default()
2953 .to_len_sz(field.len() as u64, force_canonical),
2954 )?;
2955 for element in field.iter() {
2956 element.serialize(serializer, force_canonical)?;
2957 }
2958 self.encodings
2959 .as_ref()
2960 .map(|encs| encs.reference_inputs_encoding)
2961 .unwrap_or_default()
2962 .end(serializer, force_canonical)?;
2963 }
2964 }
2965 _ => unreachable!(),
2966 };
2967 }
2968 self.encodings
2969 .as_ref()
2970 .map(|encs| encs.len_encoding)
2971 .unwrap_or_default()
2972 .end(serializer, force_canonical)
2973 }
2974}
2975
2976impl Deserialize for BabbageTransactionBody {
2977 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2978 let len = raw.map_sz()?;
2979 let len_encoding: LenEncoding = len.into();
2980 let mut read_len = CBORReadLen::new(len);
2981 read_len.read_elems(3)?;
2982 (|| -> Result<_, DeserializeError> {
2983 let mut orig_deser_order = Vec::new();
2984 let mut inputs_encoding = LenEncoding::default();
2985 let mut inputs_key_encoding = None;
2986 let mut inputs = None;
2987 let mut outputs_encoding = LenEncoding::default();
2988 let mut outputs_key_encoding = None;
2989 let mut outputs = None;
2990 let mut fee_encoding = None;
2991 let mut fee_key_encoding = None;
2992 let mut fee = None;
2993 let mut ttl_encoding = None;
2994 let mut ttl_key_encoding = None;
2995 let mut ttl = None;
2996 let mut certs_encoding = LenEncoding::default();
2997 let mut certs_key_encoding = None;
2998 let mut certs = None;
2999 let mut withdrawals_encoding = LenEncoding::default();
3000 let mut withdrawals_value_encodings = BTreeMap::new();
3001 let mut withdrawals_key_encoding = None;
3002 let mut withdrawals = None;
3003 let mut update_key_encoding = None;
3004 let mut update = None;
3005 let mut auxiliary_data_hash_encoding = StringEncoding::default();
3006 let mut auxiliary_data_hash_key_encoding = None;
3007 let mut auxiliary_data_hash = None;
3008 let mut validity_interval_start_encoding = None;
3009 let mut validity_interval_start_key_encoding = None;
3010 let mut validity_interval_start = None;
3011 let mut mint_key_encoding = None;
3012 let mut mint = None;
3013 let mut script_data_hash_encoding = StringEncoding::default();
3014 let mut script_data_hash_key_encoding = None;
3015 let mut script_data_hash = None;
3016 let mut collateral_inputs_encoding = LenEncoding::default();
3017 let mut collateral_inputs_key_encoding = None;
3018 let mut collateral_inputs = None;
3019 let mut required_signers_encoding = LenEncoding::default();
3020 let mut required_signers_elem_encodings = Vec::new();
3021 let mut required_signers_key_encoding = None;
3022 let mut required_signers = None;
3023 let mut network_id_key_encoding = None;
3024 let mut network_id = None;
3025 let mut collateral_return_key_encoding = None;
3026 let mut collateral_return = None;
3027 let mut total_collateral_encoding = None;
3028 let mut total_collateral_key_encoding = None;
3029 let mut total_collateral = None;
3030 let mut reference_inputs_encoding = LenEncoding::default();
3031 let mut reference_inputs_key_encoding = None;
3032 let mut reference_inputs = None;
3033 let mut read = 0;
3034 while match len { cbor_event::LenSz::Len(n, _) => read < n, cbor_event::LenSz::Indefinite => true, } {
3035 match raw.cbor_type()? {
3036 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
3037 (0, key_enc) => {
3038 if inputs.is_some() {
3039 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
3040 }
3041 let (tmp_inputs, tmp_inputs_encoding) = (|| -> Result<_, DeserializeError> {
3042 let mut inputs_arr = Vec::new();
3043 let len = raw.array_sz()?;
3044 let inputs_encoding = len.into();
3045 while match len { cbor_event::LenSz::Len(n, _) => (inputs_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
3046 if raw.cbor_type()? == cbor_event::Type::Special {
3047 assert_eq!(raw.special()?, cbor_event::Special::Break);
3048 break;
3049 }
3050 inputs_arr.push(TransactionInput::deserialize(raw)?);
3051 }
3052 Ok((inputs_arr, inputs_encoding))
3053 })().map_err(|e| e.annotate("inputs"))?;
3054 inputs = Some(tmp_inputs);
3055 inputs_encoding = tmp_inputs_encoding;
3056 inputs_key_encoding = Some(key_enc);
3057 orig_deser_order.push(0);
3058 },
3059 (1, key_enc) => {
3060 if outputs.is_some() {
3061 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
3062 }
3063 let (tmp_outputs, tmp_outputs_encoding) = (|| -> Result<_, DeserializeError> {
3064 let mut outputs_arr = Vec::new();
3065 let len = raw.array_sz()?;
3066 let outputs_encoding = len.into();
3067 while match len { cbor_event::LenSz::Len(n, _) => (outputs_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
3068 if raw.cbor_type()? == cbor_event::Type::Special {
3069 assert_eq!(raw.special()?, cbor_event::Special::Break);
3070 break;
3071 }
3072 outputs_arr.push(BabbageTransactionOutput::deserialize(raw)?);
3073 }
3074 Ok((outputs_arr, outputs_encoding))
3075 })().map_err(|e| e.annotate("outputs"))?;
3076 outputs = Some(tmp_outputs);
3077 outputs_encoding = tmp_outputs_encoding;
3078 outputs_key_encoding = Some(key_enc);
3079 orig_deser_order.push(1);
3080 },
3081 (2, key_enc) => {
3082 if fee.is_some() {
3083 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
3084 }
3085 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"))?;
3086 fee = Some(tmp_fee);
3087 fee_encoding = tmp_fee_encoding;
3088 fee_key_encoding = Some(key_enc);
3089 orig_deser_order.push(2);
3090 },
3091 (3, key_enc) => {
3092 if ttl.is_some() {
3093 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
3094 }
3095 let (tmp_ttl, tmp_ttl_encoding) = (|| -> Result<_, DeserializeError> {
3096 read_len.read_elems(1)?;
3097 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
3098 })().map_err(|e| e.annotate("ttl"))?;
3099 ttl = Some(tmp_ttl);
3100 ttl_encoding = tmp_ttl_encoding;
3101 ttl_key_encoding = Some(key_enc);
3102 orig_deser_order.push(3);
3103 },
3104 (4, key_enc) => {
3105 if certs.is_some() {
3106 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
3107 }
3108 let (tmp_certs, tmp_certs_encoding) = (|| -> Result<_, DeserializeError> {
3109 read_len.read_elems(1)?;
3110 let mut certs_arr = Vec::new();
3111 let len = raw.array_sz()?;
3112 let certs_encoding = len.into();
3113 while match len { cbor_event::LenSz::Len(n, _) => (certs_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
3114 if raw.cbor_type()? == cbor_event::Type::Special {
3115 assert_eq!(raw.special()?, cbor_event::Special::Break);
3116 break;
3117 }
3118 certs_arr.push(AllegraCertificate::deserialize(raw)?);
3119 }
3120 Ok((certs_arr, certs_encoding))
3121 })().map_err(|e| e.annotate("certs"))?;
3122 certs = Some(tmp_certs);
3123 certs_encoding = tmp_certs_encoding;
3124 certs_key_encoding = Some(key_enc);
3125 orig_deser_order.push(4);
3126 },
3127 (5, key_enc) => {
3128 if withdrawals.is_some() {
3129 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
3130 }
3131 let (tmp_withdrawals, tmp_withdrawals_encoding, tmp_withdrawals_value_encodings) = (|| -> Result<_, DeserializeError> {
3132 read_len.read_elems(1)?;
3133 let mut withdrawals_table = OrderedHashMap::new();
3134 let withdrawals_len = raw.map_sz()?;
3135 let withdrawals_encoding = withdrawals_len.into();
3136 let mut withdrawals_value_encodings = BTreeMap::new();
3137 while match withdrawals_len { cbor_event::LenSz::Len(n, _) => (withdrawals_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
3138 if raw.cbor_type()? == cbor_event::Type::Special {
3139 assert_eq!(raw.special()?, cbor_event::Special::Break);
3140 break;
3141 }
3142 let withdrawals_key = RewardAccount::deserialize(raw)?;
3143 let (withdrawals_value, withdrawals_value_encoding) = raw.unsigned_integer_sz().map(|(x, enc)| (x, Some(enc)))?;
3144 if withdrawals_table.insert(withdrawals_key.clone(), withdrawals_value).is_some() {
3145 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
3146 }
3147 withdrawals_value_encodings.insert(withdrawals_key, withdrawals_value_encoding);
3148 }
3149 Ok((withdrawals_table, withdrawals_encoding, withdrawals_value_encodings))
3150 })().map_err(|e| e.annotate("withdrawals"))?;
3151 withdrawals = Some(tmp_withdrawals);
3152 withdrawals_encoding = tmp_withdrawals_encoding;
3153 withdrawals_value_encodings = tmp_withdrawals_value_encodings;
3154 withdrawals_key_encoding = Some(key_enc);
3155 orig_deser_order.push(5);
3156 },
3157 (6, key_enc) => {
3158 if update.is_some() {
3159 return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
3160 }
3161 let tmp_update = (|| -> Result<_, DeserializeError> {
3162 read_len.read_elems(1)?;
3163 BabbageUpdate::deserialize(raw)
3164 })().map_err(|e| e.annotate("update"))?;
3165 update = Some(tmp_update);
3166 update_key_encoding = Some(key_enc);
3167 orig_deser_order.push(6);
3168 },
3169 (7, key_enc) => {
3170 if auxiliary_data_hash.is_some() {
3171 return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
3172 }
3173 let (tmp_auxiliary_data_hash, tmp_auxiliary_data_hash_encoding) = (|| -> Result<_, DeserializeError> {
3174 read_len.read_elems(1)?;
3175 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()))
3176 })().map_err(|e| e.annotate("auxiliary_data_hash"))?;
3177 auxiliary_data_hash = Some(tmp_auxiliary_data_hash);
3178 auxiliary_data_hash_encoding = tmp_auxiliary_data_hash_encoding;
3179 auxiliary_data_hash_key_encoding = Some(key_enc);
3180 orig_deser_order.push(7);
3181 },
3182 (8, key_enc) => {
3183 if validity_interval_start.is_some() {
3184 return Err(DeserializeFailure::DuplicateKey(Key::Uint(8)).into());
3185 }
3186 let (tmp_validity_interval_start, tmp_validity_interval_start_encoding) = (|| -> Result<_, DeserializeError> {
3187 read_len.read_elems(1)?;
3188 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
3189 })().map_err(|e| e.annotate("validity_interval_start"))?;
3190 validity_interval_start = Some(tmp_validity_interval_start);
3191 validity_interval_start_encoding = tmp_validity_interval_start_encoding;
3192 validity_interval_start_key_encoding = Some(key_enc);
3193 orig_deser_order.push(8);
3194 },
3195 (9, key_enc) => {
3196 if mint.is_some() {
3197 return Err(DeserializeFailure::DuplicateKey(Key::Uint(9)).into());
3198 }
3199 let tmp_mint = (|| -> Result<_, DeserializeError> {
3200 read_len.read_elems(1)?;
3201 BabbageMint::deserialize(raw)
3202 })().map_err(|e| e.annotate("mint"))?;
3203 mint = Some(tmp_mint);
3204 mint_key_encoding = Some(key_enc);
3205 orig_deser_order.push(9);
3206 },
3207 (11, key_enc) => {
3208 if script_data_hash.is_some() {
3209 return Err(DeserializeFailure::DuplicateKey(Key::Uint(11)).into());
3210 }
3211 let (tmp_script_data_hash, tmp_script_data_hash_encoding) = (|| -> Result<_, DeserializeError> {
3212 read_len.read_elems(1)?;
3213 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()))
3214 })().map_err(|e| e.annotate("script_data_hash"))?;
3215 script_data_hash = Some(tmp_script_data_hash);
3216 script_data_hash_encoding = tmp_script_data_hash_encoding;
3217 script_data_hash_key_encoding = Some(key_enc);
3218 orig_deser_order.push(10);
3219 },
3220 (13, key_enc) => {
3221 if collateral_inputs.is_some() {
3222 return Err(DeserializeFailure::DuplicateKey(Key::Uint(13)).into());
3223 }
3224 let (tmp_collateral_inputs, tmp_collateral_inputs_encoding) = (|| -> Result<_, DeserializeError> {
3225 read_len.read_elems(1)?;
3226 let mut collateral_inputs_arr = Vec::new();
3227 let len = raw.array_sz()?;
3228 let collateral_inputs_encoding = len.into();
3229 while match len { cbor_event::LenSz::Len(n, _) => (collateral_inputs_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
3230 if raw.cbor_type()? == cbor_event::Type::Special {
3231 assert_eq!(raw.special()?, cbor_event::Special::Break);
3232 break;
3233 }
3234 collateral_inputs_arr.push(TransactionInput::deserialize(raw)?);
3235 }
3236 Ok((collateral_inputs_arr, collateral_inputs_encoding))
3237 })().map_err(|e| e.annotate("collateral_inputs"))?;
3238 collateral_inputs = Some(tmp_collateral_inputs);
3239 collateral_inputs_encoding = tmp_collateral_inputs_encoding;
3240 collateral_inputs_key_encoding = Some(key_enc);
3241 orig_deser_order.push(11);
3242 },
3243 (14, key_enc) => {
3244 if required_signers.is_some() {
3245 return Err(DeserializeFailure::DuplicateKey(Key::Uint(14)).into());
3246 }
3247 let (tmp_required_signers, tmp_required_signers_encoding, tmp_required_signers_elem_encodings) = (|| -> Result<_, DeserializeError> {
3248 read_len.read_elems(1)?;
3249 let mut required_signers_arr = Vec::new();
3250 let len = raw.array_sz()?;
3251 let required_signers_encoding = len.into();
3252 let mut required_signers_elem_encodings = Vec::new();
3253 while match len { cbor_event::LenSz::Len(n, _) => (required_signers_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
3254 if raw.cbor_type()? == cbor_event::Type::Special {
3255 assert_eq!(raw.special()?, cbor_event::Special::Break);
3256 break;
3257 }
3258 let (required_signers_elem, required_signers_elem_encoding) = raw.bytes_sz().map_err(Into::<DeserializeError>::into).and_then(|(bytes, enc)| Ed25519KeyHash::from_raw_bytes(&bytes).map(|bytes| (bytes, StringEncoding::from(enc))).map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into()))?;
3259 required_signers_arr.push(required_signers_elem);
3260 required_signers_elem_encodings.push(required_signers_elem_encoding);
3261 }
3262 Ok((required_signers_arr, required_signers_encoding, required_signers_elem_encodings))
3263 })().map_err(|e| e.annotate("required_signers"))?;
3264 required_signers = Some(tmp_required_signers);
3265 required_signers_encoding = tmp_required_signers_encoding;
3266 required_signers_elem_encodings = tmp_required_signers_elem_encodings;
3267 required_signers_key_encoding = Some(key_enc);
3268 orig_deser_order.push(12);
3269 },
3270 (15, key_enc) => {
3271 if network_id.is_some() {
3272 return Err(DeserializeFailure::DuplicateKey(Key::Uint(15)).into());
3273 }
3274 let tmp_network_id = (|| -> Result<_, DeserializeError> {
3275 read_len.read_elems(1)?;
3276 NetworkId::deserialize(raw)
3277 })().map_err(|e| e.annotate("network_id"))?;
3278 network_id = Some(tmp_network_id);
3279 network_id_key_encoding = Some(key_enc);
3280 orig_deser_order.push(13);
3281 },
3282 (16, key_enc) => {
3283 if collateral_return.is_some() {
3284 return Err(DeserializeFailure::DuplicateKey(Key::Uint(16)).into());
3285 }
3286 let tmp_collateral_return = (|| -> Result<_, DeserializeError> {
3287 read_len.read_elems(1)?;
3288 BabbageTransactionOutput::deserialize(raw)
3289 })().map_err(|e| e.annotate("collateral_return"))?;
3290 collateral_return = Some(tmp_collateral_return);
3291 collateral_return_key_encoding = Some(key_enc);
3292 orig_deser_order.push(14);
3293 },
3294 (17, key_enc) => {
3295 if total_collateral.is_some() {
3296 return Err(DeserializeFailure::DuplicateKey(Key::Uint(17)).into());
3297 }
3298 let (tmp_total_collateral, tmp_total_collateral_encoding) = (|| -> Result<_, DeserializeError> {
3299 read_len.read_elems(1)?;
3300 raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
3301 })().map_err(|e| e.annotate("total_collateral"))?;
3302 total_collateral = Some(tmp_total_collateral);
3303 total_collateral_encoding = tmp_total_collateral_encoding;
3304 total_collateral_key_encoding = Some(key_enc);
3305 orig_deser_order.push(15);
3306 },
3307 (18, key_enc) => {
3308 if reference_inputs.is_some() {
3309 return Err(DeserializeFailure::DuplicateKey(Key::Uint(18)).into());
3310 }
3311 let (tmp_reference_inputs, tmp_reference_inputs_encoding) = (|| -> Result<_, DeserializeError> {
3312 read_len.read_elems(1)?;
3313 let mut reference_inputs_arr = Vec::new();
3314 let len = raw.array_sz()?;
3315 let reference_inputs_encoding = len.into();
3316 while match len { cbor_event::LenSz::Len(n, _) => (reference_inputs_arr.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
3317 if raw.cbor_type()? == cbor_event::Type::Special {
3318 assert_eq!(raw.special()?, cbor_event::Special::Break);
3319 break;
3320 }
3321 reference_inputs_arr.push(TransactionInput::deserialize(raw)?);
3322 }
3323 Ok((reference_inputs_arr, reference_inputs_encoding))
3324 })().map_err(|e| e.annotate("reference_inputs"))?;
3325 reference_inputs = Some(tmp_reference_inputs);
3326 reference_inputs_encoding = tmp_reference_inputs_encoding;
3327 reference_inputs_key_encoding = Some(key_enc);
3328 orig_deser_order.push(16);
3329 },
3330 (unknown_key, _enc) => return Err(DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()),
3331 },
3332 cbor_event::Type::Text => return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into()),
3333 cbor_event::Type::Special => match len {
3334 cbor_event::LenSz::Len(_, _) => return Err(DeserializeFailure::BreakInDefiniteLen.into()),
3335 cbor_event::LenSz::Indefinite => match raw.special()? {
3336 cbor_event::Special::Break => break,
3337 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3338 },
3339 },
3340 other_type => return Err(DeserializeFailure::UnexpectedKeyType(other_type).into()),
3341 }
3342 read += 1;
3343 }
3344 let inputs = match inputs {
3345 Some(x) => x,
3346 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(0)).into()),
3347 };
3348 let outputs = match outputs {
3349 Some(x) => x,
3350 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(1)).into()),
3351 };
3352 let fee = match fee {
3353 Some(x) => x,
3354 None => return Err(DeserializeFailure::MandatoryFieldMissing(Key::Uint(2)).into()),
3355 };
3356 read_len.finish()?;
3357 Ok(Self {
3358 inputs,
3359 outputs,
3360 fee,
3361 ttl,
3362 certs,
3363 withdrawals,
3364 update,
3365 auxiliary_data_hash,
3366 validity_interval_start,
3367 mint,
3368 script_data_hash,
3369 collateral_inputs,
3370 required_signers: required_signers.map(Into::into),
3371 network_id,
3372 collateral_return,
3373 total_collateral,
3374 reference_inputs,
3375 encodings: Some(BabbageTransactionBodyEncoding {
3376 len_encoding,
3377 orig_deser_order,
3378 inputs_key_encoding,
3379 inputs_encoding,
3380 outputs_key_encoding,
3381 outputs_encoding,
3382 fee_key_encoding,
3383 fee_encoding,
3384 ttl_key_encoding,
3385 ttl_encoding,
3386 certs_key_encoding,
3387 certs_encoding,
3388 withdrawals_key_encoding,
3389 withdrawals_encoding,
3390 withdrawals_value_encodings,
3391 update_key_encoding,
3392 auxiliary_data_hash_key_encoding,
3393 auxiliary_data_hash_encoding,
3394 validity_interval_start_key_encoding,
3395 validity_interval_start_encoding,
3396 mint_key_encoding,
3397 script_data_hash_key_encoding,
3398 script_data_hash_encoding,
3399 collateral_inputs_key_encoding,
3400 collateral_inputs_encoding,
3401 required_signers_key_encoding,
3402 required_signers_encoding,
3403 required_signers_elem_encodings,
3404 network_id_key_encoding,
3405 collateral_return_key_encoding,
3406 total_collateral_key_encoding,
3407 total_collateral_encoding,
3408 reference_inputs_key_encoding,
3409 reference_inputs_encoding,
3410 }),
3411 })
3412 })().map_err(|e| e.annotate("BabbageTransactionBody"))
3413 }
3414}
3415
3416impl Serialize for BabbageTransactionOutput {
3417 fn serialize<'se, W: Write>(
3418 &self,
3419 serializer: &'se mut Serializer<W>,
3420 force_canonical: bool,
3421 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3422 match self {
3423 BabbageTransactionOutput::AlonzoFormatTxOut(alonzo_format_tx_out) => {
3424 alonzo_format_tx_out.serialize(serializer, force_canonical)
3425 }
3426 BabbageTransactionOutput::BabbageFormatTxOut(babbage_format_tx_out) => {
3427 babbage_format_tx_out.serialize(serializer, force_canonical)
3428 }
3429 }
3430 }
3431}
3432
3433impl Deserialize for BabbageTransactionOutput {
3434 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3435 (|| -> Result<_, DeserializeError> {
3436 let initial_position = raw.as_mut_ref().stream_position().unwrap();
3437 let mut errs = Vec::new();
3438 let deser_variant: Result<_, DeserializeError> = AlonzoFormatTxOut::deserialize(raw);
3439 match deser_variant {
3440 Ok(alonzo_format_tx_out) => {
3441 return Ok(Self::AlonzoFormatTxOut(alonzo_format_tx_out))
3442 }
3443 Err(e) => {
3444 errs.push(e.annotate("AlonzoFormatTxOut"));
3445 raw.as_mut_ref()
3446 .seek(SeekFrom::Start(initial_position))
3447 .unwrap();
3448 }
3449 };
3450 let deser_variant: Result<_, DeserializeError> = BabbageFormatTxOut::deserialize(raw);
3451 match deser_variant {
3452 Ok(babbage_format_tx_out) => {
3453 return Ok(Self::BabbageFormatTxOut(babbage_format_tx_out))
3454 }
3455 Err(e) => {
3456 errs.push(e.annotate("BabbageFormatTxOut"));
3457 raw.as_mut_ref()
3458 .seek(SeekFrom::Start(initial_position))
3459 .unwrap();
3460 }
3461 };
3462 Err(DeserializeError::new(
3463 "BabbageTransactionOutput",
3464 DeserializeFailure::NoVariantMatchedWithCauses(errs),
3465 ))
3466 })()
3467 .map_err(|e| e.annotate("BabbageTransactionOutput"))
3468 }
3469}
3470
3471impl Serialize for BabbageTransactionWitnessSet {
3472 fn serialize<'se, W: Write>(
3473 &self,
3474 serializer: &'se mut Serializer<W>,
3475 force_canonical: bool,
3476 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3477 serializer.write_map_sz(
3478 self.encodings
3479 .as_ref()
3480 .map(|encs| encs.len_encoding)
3481 .unwrap_or_default()
3482 .to_len_sz(
3483 match &self.vkeywitnesses {
3484 Some(_) => 1,
3485 None => 0,
3486 } + match &self.native_scripts {
3487 Some(_) => 1,
3488 None => 0,
3489 } + match &self.bootstrap_witnesses {
3490 Some(_) => 1,
3491 None => 0,
3492 } + match &self.plutus_v1_scripts {
3493 Some(_) => 1,
3494 None => 0,
3495 } + match &self.plutus_datums {
3496 Some(_) => 1,
3497 None => 0,
3498 } + match &self.redeemers {
3499 Some(_) => 1,
3500 None => 0,
3501 } + match &self.plutus_v2_scripts {
3502 Some(_) => 1,
3503 None => 0,
3504 },
3505 force_canonical,
3506 ),
3507 )?;
3508 let deser_order = self
3509 .encodings
3510 .as_ref()
3511 .filter(|encs| {
3512 !force_canonical
3513 && encs.orig_deser_order.len()
3514 == match &self.vkeywitnesses {
3515 Some(_) => 1,
3516 None => 0,
3517 } + match &self.native_scripts {
3518 Some(_) => 1,
3519 None => 0,
3520 } + match &self.bootstrap_witnesses {
3521 Some(_) => 1,
3522 None => 0,
3523 } + match &self.plutus_v1_scripts {
3524 Some(_) => 1,
3525 None => 0,
3526 } + match &self.plutus_datums {
3527 Some(_) => 1,
3528 None => 0,
3529 } + match &self.redeemers {
3530 Some(_) => 1,
3531 None => 0,
3532 } + match &self.plutus_v2_scripts {
3533 Some(_) => 1,
3534 None => 0,
3535 }
3536 })
3537 .map(|encs| encs.orig_deser_order.clone())
3538 .unwrap_or_else(|| vec![0, 1, 2, 3, 4, 5, 6]);
3539 for field_index in deser_order {
3540 match field_index {
3541 0 => {
3542 if let Some(field) = &self.vkeywitnesses {
3543 serializer.write_unsigned_integer_sz(
3544 0u64,
3545 fit_sz(
3546 0u64,
3547 self.encodings
3548 .as_ref()
3549 .map(|encs| encs.vkeywitnesses_key_encoding)
3550 .unwrap_or_default(),
3551 force_canonical,
3552 ),
3553 )?;
3554 serializer.write_array_sz(
3555 self.encodings
3556 .as_ref()
3557 .map(|encs| encs.vkeywitnesses_encoding)
3558 .unwrap_or_default()
3559 .to_len_sz(field.len() as u64, force_canonical),
3560 )?;
3561 for element in field.iter() {
3562 element.serialize(serializer, force_canonical)?;
3563 }
3564 self.encodings
3565 .as_ref()
3566 .map(|encs| encs.vkeywitnesses_encoding)
3567 .unwrap_or_default()
3568 .end(serializer, force_canonical)?;
3569 }
3570 }
3571 1 => {
3572 if let Some(field) = &self.native_scripts {
3573 serializer.write_unsigned_integer_sz(
3574 1u64,
3575 fit_sz(
3576 1u64,
3577 self.encodings
3578 .as_ref()
3579 .map(|encs| encs.native_scripts_key_encoding)
3580 .unwrap_or_default(),
3581 force_canonical,
3582 ),
3583 )?;
3584 serializer.write_array_sz(
3585 self.encodings
3586 .as_ref()
3587 .map(|encs| encs.native_scripts_encoding)
3588 .unwrap_or_default()
3589 .to_len_sz(field.len() as u64, force_canonical),
3590 )?;
3591 for element in field.iter() {
3592 element.serialize(serializer, force_canonical)?;
3593 }
3594 self.encodings
3595 .as_ref()
3596 .map(|encs| encs.native_scripts_encoding)
3597 .unwrap_or_default()
3598 .end(serializer, force_canonical)?;
3599 }
3600 }
3601 2 => {
3602 if let Some(field) = &self.bootstrap_witnesses {
3603 serializer.write_unsigned_integer_sz(
3604 2u64,
3605 fit_sz(
3606 2u64,
3607 self.encodings
3608 .as_ref()
3609 .map(|encs| encs.bootstrap_witnesses_key_encoding)
3610 .unwrap_or_default(),
3611 force_canonical,
3612 ),
3613 )?;
3614 serializer.write_array_sz(
3615 self.encodings
3616 .as_ref()
3617 .map(|encs| encs.bootstrap_witnesses_encoding)
3618 .unwrap_or_default()
3619 .to_len_sz(field.len() as u64, force_canonical),
3620 )?;
3621 for element in field.iter() {
3622 element.serialize(serializer, force_canonical)?;
3623 }
3624 self.encodings
3625 .as_ref()
3626 .map(|encs| encs.bootstrap_witnesses_encoding)
3627 .unwrap_or_default()
3628 .end(serializer, force_canonical)?;
3629 }
3630 }
3631 3 => {
3632 if let Some(field) = &self.plutus_v1_scripts {
3633 serializer.write_unsigned_integer_sz(
3634 3u64,
3635 fit_sz(
3636 3u64,
3637 self.encodings
3638 .as_ref()
3639 .map(|encs| encs.plutus_v1_scripts_key_encoding)
3640 .unwrap_or_default(),
3641 force_canonical,
3642 ),
3643 )?;
3644 serializer.write_array_sz(
3645 self.encodings
3646 .as_ref()
3647 .map(|encs| encs.plutus_v1_scripts_encoding)
3648 .unwrap_or_default()
3649 .to_len_sz(field.len() as u64, force_canonical),
3650 )?;
3651 for element in field.iter() {
3652 element.serialize(serializer, force_canonical)?;
3653 }
3654 self.encodings
3655 .as_ref()
3656 .map(|encs| encs.plutus_v1_scripts_encoding)
3657 .unwrap_or_default()
3658 .end(serializer, force_canonical)?;
3659 }
3660 }
3661 4 => {
3662 if let Some(field) = &self.plutus_datums {
3663 serializer.write_unsigned_integer_sz(
3664 4u64,
3665 fit_sz(
3666 4u64,
3667 self.encodings
3668 .as_ref()
3669 .map(|encs| encs.plutus_datums_key_encoding)
3670 .unwrap_or_default(),
3671 force_canonical,
3672 ),
3673 )?;
3674 serializer.write_array_sz(
3675 self.encodings
3676 .as_ref()
3677 .map(|encs| encs.plutus_datums_encoding)
3678 .unwrap_or_default()
3679 .to_len_sz(field.len() as u64, force_canonical),
3680 )?;
3681 for element in field.iter() {
3682 element.serialize(serializer, force_canonical)?;
3683 }
3684 self.encodings
3685 .as_ref()
3686 .map(|encs| encs.plutus_datums_encoding)
3687 .unwrap_or_default()
3688 .end(serializer, force_canonical)?;
3689 }
3690 }
3691 5 => {
3692 if let Some(field) = &self.redeemers {
3693 serializer.write_unsigned_integer_sz(
3694 5u64,
3695 fit_sz(
3696 5u64,
3697 self.encodings
3698 .as_ref()
3699 .map(|encs| encs.redeemers_key_encoding)
3700 .unwrap_or_default(),
3701 force_canonical,
3702 ),
3703 )?;
3704 serializer.write_array_sz(
3705 self.encodings
3706 .as_ref()
3707 .map(|encs| encs.redeemers_encoding)
3708 .unwrap_or_default()
3709 .to_len_sz(field.len() as u64, force_canonical),
3710 )?;
3711 for element in field.iter() {
3712 element.serialize(serializer, force_canonical)?;
3713 }
3714 self.encodings
3715 .as_ref()
3716 .map(|encs| encs.redeemers_encoding)
3717 .unwrap_or_default()
3718 .end(serializer, force_canonical)?;
3719 }
3720 }
3721 6 => {
3722 if let Some(field) = &self.plutus_v2_scripts {
3723 serializer.write_unsigned_integer_sz(
3724 6u64,
3725 fit_sz(
3726 6u64,
3727 self.encodings
3728 .as_ref()
3729 .map(|encs| encs.plutus_v2_scripts_key_encoding)
3730 .unwrap_or_default(),
3731 force_canonical,
3732 ),
3733 )?;
3734 serializer.write_array_sz(
3735 self.encodings
3736 .as_ref()
3737 .map(|encs| encs.plutus_v2_scripts_encoding)
3738 .unwrap_or_default()
3739 .to_len_sz(field.len() as u64, force_canonical),
3740 )?;
3741 for element in field.iter() {
3742 element.serialize(serializer, force_canonical)?;
3743 }
3744 self.encodings
3745 .as_ref()
3746 .map(|encs| encs.plutus_v2_scripts_encoding)
3747 .unwrap_or_default()
3748 .end(serializer, force_canonical)?;
3749 }
3750 }
3751 _ => unreachable!(),
3752 };
3753 }
3754 self.encodings
3755 .as_ref()
3756 .map(|encs| encs.len_encoding)
3757 .unwrap_or_default()
3758 .end(serializer, force_canonical)
3759 }
3760}
3761
3762impl Deserialize for BabbageTransactionWitnessSet {
3763 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3764 let len = raw.map_sz()?;
3765 let len_encoding: LenEncoding = len.into();
3766 let mut read_len = CBORReadLen::new(len);
3767 (|| -> Result<_, DeserializeError> {
3768 let mut orig_deser_order = Vec::new();
3769 let mut vkeywitnesses_encoding = LenEncoding::default();
3770 let mut vkeywitnesses_key_encoding = None;
3771 let mut vkeywitnesses = None;
3772 let mut native_scripts_encoding = LenEncoding::default();
3773 let mut native_scripts_key_encoding = None;
3774 let mut native_scripts = None;
3775 let mut bootstrap_witnesses_encoding = LenEncoding::default();
3776 let mut bootstrap_witnesses_key_encoding = None;
3777 let mut bootstrap_witnesses = None;
3778 let mut plutus_v1_scripts_encoding = LenEncoding::default();
3779 let mut plutus_v1_scripts_key_encoding = None;
3780 let mut plutus_v1_scripts = None;
3781 let mut plutus_datums_encoding = LenEncoding::default();
3782 let mut plutus_datums_key_encoding = None;
3783 let mut plutus_datums = None;
3784 let mut redeemers_encoding = LenEncoding::default();
3785 let mut redeemers_key_encoding = None;
3786 let mut redeemers = None;
3787 let mut plutus_v2_scripts_encoding = LenEncoding::default();
3788 let mut plutus_v2_scripts_key_encoding = None;
3789 let mut plutus_v2_scripts = None;
3790 let mut read = 0;
3791 while match len {
3792 cbor_event::LenSz::Len(n, _) => read < n,
3793 cbor_event::LenSz::Indefinite => true,
3794 } {
3795 match raw.cbor_type()? {
3796 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
3797 (0, key_enc) => {
3798 if vkeywitnesses.is_some() {
3799 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
3800 }
3801 let (tmp_vkeywitnesses, tmp_vkeywitnesses_encoding) =
3802 (|| -> Result<_, DeserializeError> {
3803 read_len.read_elems(1)?;
3804 let mut vkeywitnesses_arr = Vec::new();
3805 let len = raw.array_sz()?;
3806 let vkeywitnesses_encoding = len.into();
3807 while match len {
3808 cbor_event::LenSz::Len(n, _) => {
3809 (vkeywitnesses_arr.len() as u64) < n
3810 }
3811 cbor_event::LenSz::Indefinite => true,
3812 } {
3813 if raw.cbor_type()? == cbor_event::Type::Special {
3814 assert_eq!(raw.special()?, cbor_event::Special::Break);
3815 break;
3816 }
3817 vkeywitnesses_arr.push(Vkeywitness::deserialize(raw)?);
3818 }
3819 Ok((vkeywitnesses_arr, vkeywitnesses_encoding))
3820 })()
3821 .map_err(|e| e.annotate("vkeywitnesses"))?;
3822 vkeywitnesses = Some(tmp_vkeywitnesses);
3823 vkeywitnesses_encoding = tmp_vkeywitnesses_encoding;
3824 vkeywitnesses_key_encoding = Some(key_enc);
3825 orig_deser_order.push(0);
3826 }
3827 (1, key_enc) => {
3828 if native_scripts.is_some() {
3829 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
3830 }
3831 let (tmp_native_scripts, tmp_native_scripts_encoding) =
3832 (|| -> Result<_, DeserializeError> {
3833 read_len.read_elems(1)?;
3834 let mut native_scripts_arr = Vec::new();
3835 let len = raw.array_sz()?;
3836 let native_scripts_encoding = len.into();
3837 while match len {
3838 cbor_event::LenSz::Len(n, _) => {
3839 (native_scripts_arr.len() as u64) < n
3840 }
3841 cbor_event::LenSz::Indefinite => true,
3842 } {
3843 if raw.cbor_type()? == cbor_event::Type::Special {
3844 assert_eq!(raw.special()?, cbor_event::Special::Break);
3845 break;
3846 }
3847 native_scripts_arr.push(NativeScript::deserialize(raw)?);
3848 }
3849 Ok((native_scripts_arr, native_scripts_encoding))
3850 })()
3851 .map_err(|e| e.annotate("native_scripts"))?;
3852 native_scripts = Some(tmp_native_scripts);
3853 native_scripts_encoding = tmp_native_scripts_encoding;
3854 native_scripts_key_encoding = Some(key_enc);
3855 orig_deser_order.push(1);
3856 }
3857 (2, key_enc) => {
3858 if bootstrap_witnesses.is_some() {
3859 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
3860 }
3861 let (tmp_bootstrap_witnesses, tmp_bootstrap_witnesses_encoding) =
3862 (|| -> Result<_, DeserializeError> {
3863 read_len.read_elems(1)?;
3864 let mut bootstrap_witnesses_arr = Vec::new();
3865 let len = raw.array_sz()?;
3866 let bootstrap_witnesses_encoding = len.into();
3867 while match len {
3868 cbor_event::LenSz::Len(n, _) => {
3869 (bootstrap_witnesses_arr.len() as u64) < n
3870 }
3871 cbor_event::LenSz::Indefinite => true,
3872 } {
3873 if raw.cbor_type()? == cbor_event::Type::Special {
3874 assert_eq!(raw.special()?, cbor_event::Special::Break);
3875 break;
3876 }
3877 bootstrap_witnesses_arr
3878 .push(BootstrapWitness::deserialize(raw)?);
3879 }
3880 Ok((bootstrap_witnesses_arr, bootstrap_witnesses_encoding))
3881 })()
3882 .map_err(|e| e.annotate("bootstrap_witnesses"))?;
3883 bootstrap_witnesses = Some(tmp_bootstrap_witnesses);
3884 bootstrap_witnesses_encoding = tmp_bootstrap_witnesses_encoding;
3885 bootstrap_witnesses_key_encoding = Some(key_enc);
3886 orig_deser_order.push(2);
3887 }
3888 (3, key_enc) => {
3889 if plutus_v1_scripts.is_some() {
3890 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
3891 }
3892 let (tmp_plutus_v1_scripts, tmp_plutus_v1_scripts_encoding) =
3893 (|| -> Result<_, DeserializeError> {
3894 read_len.read_elems(1)?;
3895 let mut plutus_v1_scripts_arr = Vec::new();
3896 let len = raw.array_sz()?;
3897 let plutus_v1_scripts_encoding = len.into();
3898 while match len {
3899 cbor_event::LenSz::Len(n, _) => {
3900 (plutus_v1_scripts_arr.len() as u64) < n
3901 }
3902 cbor_event::LenSz::Indefinite => true,
3903 } {
3904 if raw.cbor_type()? == cbor_event::Type::Special {
3905 assert_eq!(raw.special()?, cbor_event::Special::Break);
3906 break;
3907 }
3908 plutus_v1_scripts_arr
3909 .push(PlutusV1Script::deserialize(raw)?);
3910 }
3911 Ok((plutus_v1_scripts_arr, plutus_v1_scripts_encoding))
3912 })()
3913 .map_err(|e| e.annotate("plutus_v1_scripts"))?;
3914 plutus_v1_scripts = Some(tmp_plutus_v1_scripts);
3915 plutus_v1_scripts_encoding = tmp_plutus_v1_scripts_encoding;
3916 plutus_v1_scripts_key_encoding = Some(key_enc);
3917 orig_deser_order.push(3);
3918 }
3919 (4, key_enc) => {
3920 if plutus_datums.is_some() {
3921 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
3922 }
3923 let (tmp_plutus_datums, tmp_plutus_datums_encoding) =
3924 (|| -> Result<_, DeserializeError> {
3925 read_len.read_elems(1)?;
3926 let mut plutus_datums_arr = Vec::new();
3927 let len = raw.array_sz()?;
3928 let plutus_datums_encoding = len.into();
3929 while match len {
3930 cbor_event::LenSz::Len(n, _) => {
3931 (plutus_datums_arr.len() as u64) < n
3932 }
3933 cbor_event::LenSz::Indefinite => true,
3934 } {
3935 if raw.cbor_type()? == cbor_event::Type::Special {
3936 assert_eq!(raw.special()?, cbor_event::Special::Break);
3937 break;
3938 }
3939 plutus_datums_arr.push(PlutusData::deserialize(raw)?);
3940 }
3941 Ok((plutus_datums_arr, plutus_datums_encoding))
3942 })()
3943 .map_err(|e| e.annotate("plutus_datums"))?;
3944 plutus_datums = Some(tmp_plutus_datums);
3945 plutus_datums_encoding = tmp_plutus_datums_encoding;
3946 plutus_datums_key_encoding = Some(key_enc);
3947 orig_deser_order.push(4);
3948 }
3949 (5, key_enc) => {
3950 if redeemers.is_some() {
3951 return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
3952 }
3953 let (tmp_redeemers, tmp_redeemers_encoding) =
3954 (|| -> Result<_, DeserializeError> {
3955 read_len.read_elems(1)?;
3956 let mut redeemers_arr = Vec::new();
3957 let len = raw.array_sz()?;
3958 let redeemers_encoding = len.into();
3959 while match len {
3960 cbor_event::LenSz::Len(n, _) => {
3961 (redeemers_arr.len() as u64) < n
3962 }
3963 cbor_event::LenSz::Indefinite => true,
3964 } {
3965 if raw.cbor_type()? == cbor_event::Type::Special {
3966 assert_eq!(raw.special()?, cbor_event::Special::Break);
3967 break;
3968 }
3969 redeemers_arr.push(AlonzoRedeemer::deserialize(raw)?);
3970 }
3971 Ok((redeemers_arr, redeemers_encoding))
3972 })()
3973 .map_err(|e| e.annotate("redeemers"))?;
3974 redeemers = Some(tmp_redeemers);
3975 redeemers_encoding = tmp_redeemers_encoding;
3976 redeemers_key_encoding = Some(key_enc);
3977 orig_deser_order.push(5);
3978 }
3979 (6, key_enc) => {
3980 if plutus_v2_scripts.is_some() {
3981 return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
3982 }
3983 let (tmp_plutus_v2_scripts, tmp_plutus_v2_scripts_encoding) =
3984 (|| -> Result<_, DeserializeError> {
3985 read_len.read_elems(1)?;
3986 let mut plutus_v2_scripts_arr = Vec::new();
3987 let len = raw.array_sz()?;
3988 let plutus_v2_scripts_encoding = len.into();
3989 while match len {
3990 cbor_event::LenSz::Len(n, _) => {
3991 (plutus_v2_scripts_arr.len() as u64) < n
3992 }
3993 cbor_event::LenSz::Indefinite => true,
3994 } {
3995 if raw.cbor_type()? == cbor_event::Type::Special {
3996 assert_eq!(raw.special()?, cbor_event::Special::Break);
3997 break;
3998 }
3999 plutus_v2_scripts_arr
4000 .push(PlutusV2Script::deserialize(raw)?);
4001 }
4002 Ok((plutus_v2_scripts_arr, plutus_v2_scripts_encoding))
4003 })()
4004 .map_err(|e| e.annotate("plutus_v2_scripts"))?;
4005 plutus_v2_scripts = Some(tmp_plutus_v2_scripts);
4006 plutus_v2_scripts_encoding = tmp_plutus_v2_scripts_encoding;
4007 plutus_v2_scripts_key_encoding = Some(key_enc);
4008 orig_deser_order.push(6);
4009 }
4010 (unknown_key, _enc) => {
4011 return Err(
4012 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
4013 )
4014 }
4015 },
4016 cbor_event::Type::Text => {
4017 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
4018 }
4019 cbor_event::Type::Special => match len {
4020 cbor_event::LenSz::Len(_, _) => {
4021 return Err(DeserializeFailure::BreakInDefiniteLen.into())
4022 }
4023 cbor_event::LenSz::Indefinite => match raw.special()? {
4024 cbor_event::Special::Break => break,
4025 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
4026 },
4027 },
4028 other_type => {
4029 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
4030 }
4031 }
4032 read += 1;
4033 }
4034 read_len.finish()?;
4035 Ok(Self {
4036 vkeywitnesses,
4037 native_scripts,
4038 bootstrap_witnesses,
4039 plutus_v1_scripts,
4040 plutus_datums,
4041 redeemers,
4042 plutus_v2_scripts,
4043 encodings: Some(BabbageTransactionWitnessSetEncoding {
4044 len_encoding,
4045 orig_deser_order,
4046 vkeywitnesses_key_encoding,
4047 vkeywitnesses_encoding,
4048 native_scripts_key_encoding,
4049 native_scripts_encoding,
4050 bootstrap_witnesses_key_encoding,
4051 bootstrap_witnesses_encoding,
4052 plutus_v1_scripts_key_encoding,
4053 plutus_v1_scripts_encoding,
4054 plutus_datums_key_encoding,
4055 plutus_datums_encoding,
4056 redeemers_key_encoding,
4057 redeemers_encoding,
4058 plutus_v2_scripts_key_encoding,
4059 plutus_v2_scripts_encoding,
4060 }),
4061 })
4062 })()
4063 .map_err(|e| e.annotate("BabbageTransactionWitnessSet"))
4064 }
4065}
4066
4067impl Serialize for BabbageUpdate {
4068 fn serialize<'se, W: Write>(
4069 &self,
4070 serializer: &'se mut Serializer<W>,
4071 force_canonical: bool,
4072 ) -> cbor_event::Result<&'se mut Serializer<W>> {
4073 serializer.write_array_sz(
4074 self.encodings
4075 .as_ref()
4076 .map(|encs| encs.len_encoding)
4077 .unwrap_or_default()
4078 .to_len_sz(2, force_canonical),
4079 )?;
4080 serializer.write_map_sz(
4081 self.encodings
4082 .as_ref()
4083 .map(|encs| encs.updates_encoding)
4084 .unwrap_or_default()
4085 .to_len_sz(self.updates.len() as u64, force_canonical),
4086 )?;
4087 let mut key_order = self
4088 .updates
4089 .iter()
4090 .map(|(k, v)| {
4091 let mut buf = cbor_event::se::Serializer::new_vec();
4092 let updates_key_encoding = self
4093 .encodings
4094 .as_ref()
4095 .and_then(|encs| encs.updates_key_encodings.get(k))
4096 .cloned()
4097 .unwrap_or_default();
4098 buf.write_bytes_sz(
4099 k.to_raw_bytes(),
4100 updates_key_encoding
4101 .to_str_len_sz(k.to_raw_bytes().len() as u64, force_canonical),
4102 )?;
4103 Ok((buf.finalize(), k, v))
4104 })
4105 .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
4106 if force_canonical {
4107 key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
4108 match lhs_bytes.len().cmp(&rhs_bytes.len()) {
4109 std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
4110 diff_ord => diff_ord,
4111 }
4112 });
4113 }
4114 for (key_bytes, _key, value) in key_order {
4115 serializer.write_raw_bytes(&key_bytes)?;
4116 value.serialize(serializer, force_canonical)?;
4117 }
4118 self.encodings
4119 .as_ref()
4120 .map(|encs| encs.updates_encoding)
4121 .unwrap_or_default()
4122 .end(serializer, force_canonical)?;
4123 serializer.write_unsigned_integer_sz(
4124 self.epoch,
4125 fit_sz(
4126 self.epoch,
4127 self.encodings
4128 .as_ref()
4129 .map(|encs| encs.epoch_encoding)
4130 .unwrap_or_default(),
4131 force_canonical,
4132 ),
4133 )?;
4134 self.encodings
4135 .as_ref()
4136 .map(|encs| encs.len_encoding)
4137 .unwrap_or_default()
4138 .end(serializer, force_canonical)
4139 }
4140}
4141
4142impl Deserialize for BabbageUpdate {
4143 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
4144 let len = raw.array_sz()?;
4145 let len_encoding: LenEncoding = len.into();
4146 let mut read_len = CBORReadLen::new(len);
4147 read_len.read_elems(2)?;
4148 read_len.finish()?;
4149 (|| -> Result<_, DeserializeError> {
4150 let (updates, updates_encoding, updates_key_encodings) =
4151 (|| -> Result<_, DeserializeError> {
4152 let mut updates_table = OrderedHashMap::new();
4153 let updates_len = raw.map_sz()?;
4154 let updates_encoding = updates_len.into();
4155 let mut updates_key_encodings = BTreeMap::new();
4156 while match updates_len {
4157 cbor_event::LenSz::Len(n, _) => (updates_table.len() as u64) < n,
4158 cbor_event::LenSz::Indefinite => true,
4159 } {
4160 if raw.cbor_type()? == cbor_event::Type::Special {
4161 assert_eq!(raw.special()?, cbor_event::Special::Break);
4162 break;
4163 }
4164 let (updates_key, updates_key_encoding) = raw
4165 .bytes_sz()
4166 .map_err(Into::<DeserializeError>::into)
4167 .and_then(|(bytes, enc)| {
4168 GenesisHash::from_raw_bytes(&bytes)
4169 .map(|bytes| (bytes, StringEncoding::from(enc)))
4170 .map_err(|e| {
4171 DeserializeFailure::InvalidStructure(Box::new(e)).into()
4172 })
4173 })?;
4174 let updates_value = BabbageProtocolParamUpdate::deserialize(raw)?;
4175 if updates_table.insert(updates_key, updates_value).is_some() {
4176 return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
4177 "some complicated/unsupported type",
4178 )))
4179 .into());
4180 }
4181 updates_key_encodings.insert(updates_key, updates_key_encoding);
4182 }
4183 Ok((updates_table, updates_encoding, updates_key_encodings))
4184 })()
4185 .map_err(|e| e.annotate("updates"))?;
4186 let (epoch, epoch_encoding) = raw
4187 .unsigned_integer_sz()
4188 .map_err(Into::<DeserializeError>::into)
4189 .map(|(x, enc)| (x, Some(enc)))
4190 .map_err(|e: DeserializeError| e.annotate("epoch"))?;
4191 match len {
4192 cbor_event::LenSz::Len(_, _) => (),
4193 cbor_event::LenSz::Indefinite => match raw.special()? {
4194 cbor_event::Special::Break => (),
4195 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
4196 },
4197 }
4198 Ok(BabbageUpdate {
4199 updates,
4200 epoch,
4201 encodings: Some(BabbageUpdateEncoding {
4202 len_encoding,
4203 updates_encoding,
4204 updates_key_encodings,
4205 epoch_encoding,
4206 }),
4207 })
4208 })()
4209 .map_err(|e| e.annotate("BabbageUpdate"))
4210 }
4211}