1use crate::plutus::PlutusV3Script;
5
6use super::cbor_encodings::*;
7use super::*;
8use cbor_event::de::Deserializer;
9use cbor_event::se::Serializer;
10use cml_core::error::*;
11use cml_core::serialization::*;
12use std::io::{BufRead, Seek, SeekFrom, Write};
13
14impl Serialize for AuxiliaryData {
15 fn serialize<'se, W: Write>(
16 &self,
17 serializer: &'se mut Serializer<W>,
18 force_canonical: bool,
19 ) -> cbor_event::Result<&'se mut Serializer<W>> {
20 match self {
21 AuxiliaryData::Shelley(shelley) => shelley.serialize(serializer, force_canonical),
22 AuxiliaryData::ShelleyMA(shelley_ma) => {
23 shelley_ma.serialize(serializer, force_canonical)
24 }
25 AuxiliaryData::Conway(conway) => conway.serialize(serializer, force_canonical),
26 }
27 }
28}
29
30impl Deserialize for AuxiliaryData {
31 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
32 (|| -> Result<_, DeserializeError> {
33 let initial_position = raw.as_mut_ref().stream_position().unwrap();
34 let mut errs = Vec::new();
35 let deser_variant: Result<_, DeserializeError> = Metadata::deserialize(raw);
36 match deser_variant {
37 Ok(shelley) => return Ok(Self::Shelley(shelley)),
38 Err(e) => {
39 errs.push(e.annotate("Shelley"));
40 raw.as_mut_ref()
41 .seek(SeekFrom::Start(initial_position))
42 .unwrap();
43 }
44 };
45 let deser_variant: Result<_, DeserializeError> =
46 ShelleyMAFormatAuxData::deserialize(raw);
47 match deser_variant {
48 Ok(shelley_ma) => return Ok(Self::ShelleyMA(shelley_ma)),
49 Err(e) => {
50 errs.push(e.annotate("ShelleyMA"));
51 raw.as_mut_ref()
52 .seek(SeekFrom::Start(initial_position))
53 .unwrap();
54 }
55 };
56 let deser_variant: Result<_, DeserializeError> = ConwayFormatAuxData::deserialize(raw);
57 match deser_variant {
58 Ok(conway) => return Ok(Self::Conway(conway)),
59 Err(e) => {
60 errs.push(e.annotate("Conway"));
61 raw.as_mut_ref()
62 .seek(SeekFrom::Start(initial_position))
63 .unwrap();
64 }
65 };
66 Err(DeserializeError::new(
67 "AuxiliaryData",
68 DeserializeFailure::NoVariantMatchedWithCauses(errs),
69 ))
70 })()
71 .map_err(|e| e.annotate("AuxiliaryData"))
72 }
73}
74
75impl Serialize for ConwayFormatAuxData {
76 fn serialize<'se, W: Write>(
77 &self,
78 serializer: &'se mut Serializer<W>,
79 force_canonical: bool,
80 ) -> cbor_event::Result<&'se mut Serializer<W>> {
81 serializer.write_tag_sz(
82 259u64,
83 fit_sz(
84 259u64,
85 self.encodings
86 .as_ref()
87 .map(|encs| encs.tag_encoding)
88 .unwrap_or_default(),
89 force_canonical,
90 ),
91 )?;
92 serializer.write_map_sz(
93 self.encodings
94 .as_ref()
95 .map(|encs| encs.len_encoding)
96 .unwrap_or_default()
97 .to_len_sz(
98 match &self.metadata {
99 Some(_) => 1,
100 None => 0,
101 } + match &self.native_scripts {
102 Some(_) => 1,
103 None => 0,
104 } + match &self.plutus_v1_scripts {
105 Some(_) => 1,
106 None => 0,
107 } + match &self.plutus_v2_scripts {
108 Some(_) => 1,
109 None => 0,
110 } + match &self.plutus_v3_scripts {
111 Some(_) => 1,
112 None => 0,
113 },
114 force_canonical,
115 ),
116 )?;
117 let deser_order = self
118 .encodings
119 .as_ref()
120 .filter(|encs| {
121 !force_canonical
122 && encs.orig_deser_order.len()
123 == match &self.metadata {
124 Some(_) => 1,
125 None => 0,
126 } + match &self.native_scripts {
127 Some(_) => 1,
128 None => 0,
129 } + match &self.plutus_v1_scripts {
130 Some(_) => 1,
131 None => 0,
132 } + match &self.plutus_v2_scripts {
133 Some(_) => 1,
134 None => 0,
135 } + match &self.plutus_v3_scripts {
136 Some(_) => 1,
137 None => 0,
138 }
139 })
140 .map(|encs| encs.orig_deser_order.clone())
141 .unwrap_or_else(|| vec![0, 1, 2, 3, 4]);
142 for field_index in deser_order {
143 match field_index {
144 0 => {
145 if let Some(field) = &self.metadata {
146 serializer.write_unsigned_integer_sz(
147 0u64,
148 fit_sz(
149 0u64,
150 self.encodings
151 .as_ref()
152 .map(|encs| encs.metadata_key_encoding)
153 .unwrap_or_default(),
154 force_canonical,
155 ),
156 )?;
157 field.serialize(serializer, force_canonical)?;
158 }
159 }
160 1 => {
161 if let Some(field) = &self.native_scripts {
162 serializer.write_unsigned_integer_sz(
163 1u64,
164 fit_sz(
165 1u64,
166 self.encodings
167 .as_ref()
168 .map(|encs| encs.native_scripts_key_encoding)
169 .unwrap_or_default(),
170 force_canonical,
171 ),
172 )?;
173 serializer.write_array_sz(
174 self.encodings
175 .as_ref()
176 .map(|encs| encs.native_scripts_encoding)
177 .unwrap_or_default()
178 .to_len_sz(field.len() as u64, force_canonical),
179 )?;
180 for element in field.iter() {
181 element.serialize(serializer, force_canonical)?;
182 }
183 self.encodings
184 .as_ref()
185 .map(|encs| encs.native_scripts_encoding)
186 .unwrap_or_default()
187 .end(serializer, force_canonical)?;
188 }
189 }
190 2 => {
191 if let Some(field) = &self.plutus_v1_scripts {
192 serializer.write_unsigned_integer_sz(
193 2u64,
194 fit_sz(
195 2u64,
196 self.encodings
197 .as_ref()
198 .map(|encs| encs.plutus_v1_scripts_key_encoding)
199 .unwrap_or_default(),
200 force_canonical,
201 ),
202 )?;
203 serializer.write_array_sz(
204 self.encodings
205 .as_ref()
206 .map(|encs| encs.plutus_v1_scripts_encoding)
207 .unwrap_or_default()
208 .to_len_sz(field.len() as u64, force_canonical),
209 )?;
210 for element in field.iter() {
211 element.serialize(serializer, force_canonical)?;
212 }
213 self.encodings
214 .as_ref()
215 .map(|encs| encs.plutus_v1_scripts_encoding)
216 .unwrap_or_default()
217 .end(serializer, force_canonical)?;
218 }
219 }
220 3 => {
221 if let Some(field) = &self.plutus_v2_scripts {
222 serializer.write_unsigned_integer_sz(
223 3u64,
224 fit_sz(
225 3u64,
226 self.encodings
227 .as_ref()
228 .map(|encs| encs.plutus_v2_scripts_key_encoding)
229 .unwrap_or_default(),
230 force_canonical,
231 ),
232 )?;
233 serializer.write_array_sz(
234 self.encodings
235 .as_ref()
236 .map(|encs| encs.plutus_v2_scripts_encoding)
237 .unwrap_or_default()
238 .to_len_sz(field.len() as u64, force_canonical),
239 )?;
240 for element in field.iter() {
241 element.serialize(serializer, force_canonical)?;
242 }
243 self.encodings
244 .as_ref()
245 .map(|encs| encs.plutus_v2_scripts_encoding)
246 .unwrap_or_default()
247 .end(serializer, force_canonical)?;
248 }
249 }
250 4 => {
251 if let Some(field) = &self.plutus_v3_scripts {
252 serializer.write_unsigned_integer_sz(
253 4u64,
254 fit_sz(
255 4u64,
256 self.encodings
257 .as_ref()
258 .map(|encs| encs.plutus_v3_scripts_key_encoding)
259 .unwrap_or_default(),
260 force_canonical,
261 ),
262 )?;
263 serializer.write_array_sz(
264 self.encodings
265 .as_ref()
266 .map(|encs| encs.plutus_v3_scripts_encoding)
267 .unwrap_or_default()
268 .to_len_sz(field.len() as u64, force_canonical),
269 )?;
270 for element in field.iter() {
271 element.serialize(serializer, force_canonical)?;
272 }
273 self.encodings
274 .as_ref()
275 .map(|encs| encs.plutus_v3_scripts_encoding)
276 .unwrap_or_default()
277 .end(serializer, force_canonical)?;
278 }
279 }
280 _ => unreachable!(),
281 };
282 }
283 self.encodings
284 .as_ref()
285 .map(|encs| encs.len_encoding)
286 .unwrap_or_default()
287 .end(serializer, force_canonical)
288 }
289}
290
291impl Deserialize for ConwayFormatAuxData {
292 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
293 let (tag, tag_encoding) = raw.tag_sz()?;
294 if tag != 259 {
295 return Err(DeserializeError::new(
296 "ConwayFormatAuxData",
297 DeserializeFailure::TagMismatch {
298 found: tag,
299 expected: 259,
300 },
301 ));
302 }
303 let len = raw.map_sz()?;
304 let len_encoding: LenEncoding = len.into();
305 let mut read_len = CBORReadLen::new(len);
306 (|| -> Result<_, DeserializeError> {
307 let mut orig_deser_order = Vec::new();
308 let mut metadata_key_encoding = None;
309 let mut metadata = None;
310 let mut native_scripts_encoding = LenEncoding::default();
311 let mut native_scripts_key_encoding = None;
312 let mut native_scripts = None;
313 let mut plutus_v1_scripts_encoding = LenEncoding::default();
314 let mut plutus_v1_scripts_key_encoding = None;
315 let mut plutus_v1_scripts = None;
316 let mut plutus_v2_scripts_encoding = LenEncoding::default();
317 let mut plutus_v2_scripts_key_encoding = None;
318 let mut plutus_v2_scripts = None;
319 let mut plutus_v3_scripts_encoding = LenEncoding::default();
320 let mut plutus_v3_scripts_key_encoding = None;
321 let mut plutus_v3_scripts = None;
322 let mut read = 0;
323 while match len {
324 cbor_event::LenSz::Len(n, _) => read < n,
325 cbor_event::LenSz::Indefinite => true,
326 } {
327 match raw.cbor_type()? {
328 cbor_event::Type::UnsignedInteger => match raw.unsigned_integer_sz()? {
329 (0, key_enc) => {
330 if metadata.is_some() {
331 return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
332 }
333 let tmp_metadata = (|| -> Result<_, DeserializeError> {
334 read_len.read_elems(1)?;
335 Metadata::deserialize(raw)
336 })()
337 .map_err(|e| e.annotate("metadata"))?;
338 metadata = Some(tmp_metadata);
339 metadata_key_encoding = Some(key_enc);
340 orig_deser_order.push(0);
341 }
342 (1, key_enc) => {
343 if native_scripts.is_some() {
344 return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
345 }
346 let (tmp_native_scripts, tmp_native_scripts_encoding) =
347 (|| -> Result<_, DeserializeError> {
348 read_len.read_elems(1)?;
349 let mut native_scripts_arr = Vec::new();
350 let len = raw.array_sz()?;
351 let native_scripts_encoding = len.into();
352 while match len {
353 cbor_event::LenSz::Len(n, _) => {
354 (native_scripts_arr.len() as u64) < n
355 }
356 cbor_event::LenSz::Indefinite => true,
357 } {
358 if raw.cbor_type()? == cbor_event::Type::Special {
359 assert_eq!(raw.special()?, cbor_event::Special::Break);
360 break;
361 }
362 native_scripts_arr.push(NativeScript::deserialize(raw)?);
363 }
364 Ok((native_scripts_arr, native_scripts_encoding))
365 })()
366 .map_err(|e| e.annotate("native_scripts"))?;
367 native_scripts = Some(tmp_native_scripts);
368 native_scripts_encoding = tmp_native_scripts_encoding;
369 native_scripts_key_encoding = Some(key_enc);
370 orig_deser_order.push(1);
371 }
372 (2, key_enc) => {
373 if plutus_v1_scripts.is_some() {
374 return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
375 }
376 let (tmp_plutus_v1_scripts, tmp_plutus_v1_scripts_encoding) =
377 (|| -> Result<_, DeserializeError> {
378 read_len.read_elems(1)?;
379 let mut plutus_v1_scripts_arr = Vec::new();
380 let len = raw.array_sz()?;
381 let plutus_v1_scripts_encoding = len.into();
382 while match len {
383 cbor_event::LenSz::Len(n, _) => {
384 (plutus_v1_scripts_arr.len() as u64) < n
385 }
386 cbor_event::LenSz::Indefinite => true,
387 } {
388 if raw.cbor_type()? == cbor_event::Type::Special {
389 assert_eq!(raw.special()?, cbor_event::Special::Break);
390 break;
391 }
392 plutus_v1_scripts_arr
393 .push(PlutusV1Script::deserialize(raw)?);
394 }
395 Ok((plutus_v1_scripts_arr, plutus_v1_scripts_encoding))
396 })()
397 .map_err(|e| e.annotate("plutus_v1_scripts"))?;
398 plutus_v1_scripts = Some(tmp_plutus_v1_scripts);
399 plutus_v1_scripts_encoding = tmp_plutus_v1_scripts_encoding;
400 plutus_v1_scripts_key_encoding = Some(key_enc);
401 orig_deser_order.push(2);
402 }
403 (3, key_enc) => {
404 if plutus_v2_scripts.is_some() {
405 return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
406 }
407 let (tmp_plutus_v2_scripts, tmp_plutus_v2_scripts_encoding) =
408 (|| -> Result<_, DeserializeError> {
409 read_len.read_elems(1)?;
410 let mut plutus_v2_scripts_arr = Vec::new();
411 let len = raw.array_sz()?;
412 let plutus_v2_scripts_encoding = len.into();
413 while match len {
414 cbor_event::LenSz::Len(n, _) => {
415 (plutus_v2_scripts_arr.len() as u64) < n
416 }
417 cbor_event::LenSz::Indefinite => true,
418 } {
419 if raw.cbor_type()? == cbor_event::Type::Special {
420 assert_eq!(raw.special()?, cbor_event::Special::Break);
421 break;
422 }
423 plutus_v2_scripts_arr
424 .push(PlutusV2Script::deserialize(raw)?);
425 }
426 Ok((plutus_v2_scripts_arr, plutus_v2_scripts_encoding))
427 })()
428 .map_err(|e| e.annotate("plutus_v2_scripts"))?;
429 plutus_v2_scripts = Some(tmp_plutus_v2_scripts);
430 plutus_v2_scripts_encoding = tmp_plutus_v2_scripts_encoding;
431 plutus_v2_scripts_key_encoding = Some(key_enc);
432 orig_deser_order.push(3);
433 }
434 (4, key_enc) => {
435 if plutus_v3_scripts.is_some() {
436 return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
437 }
438 let (tmp_plutus_v3_scripts, tmp_plutus_v3_scripts_encoding) =
439 (|| -> Result<_, DeserializeError> {
440 read_len.read_elems(1)?;
441 let mut plutus_v3_scripts_arr = Vec::new();
442 let len = raw.array_sz()?;
443 let plutus_v3_scripts_encoding = len.into();
444 while match len {
445 cbor_event::LenSz::Len(n, _) => {
446 (plutus_v3_scripts_arr.len() as u64) < n
447 }
448 cbor_event::LenSz::Indefinite => true,
449 } {
450 if raw.cbor_type()? == cbor_event::Type::Special {
451 assert_eq!(raw.special()?, cbor_event::Special::Break);
452 break;
453 }
454 plutus_v3_scripts_arr
455 .push(PlutusV3Script::deserialize(raw)?);
456 }
457 Ok((plutus_v3_scripts_arr, plutus_v3_scripts_encoding))
458 })()
459 .map_err(|e| e.annotate("plutus_v3_scripts"))?;
460 plutus_v3_scripts = Some(tmp_plutus_v3_scripts);
461 plutus_v3_scripts_encoding = tmp_plutus_v3_scripts_encoding;
462 plutus_v3_scripts_key_encoding = Some(key_enc);
463 orig_deser_order.push(4);
464 }
465 (unknown_key, _enc) => {
466 return Err(
467 DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()
468 )
469 }
470 },
471 cbor_event::Type::Text => {
472 return Err(DeserializeFailure::UnknownKey(Key::Str(raw.text()?)).into())
473 }
474 cbor_event::Type::Special => match len {
475 cbor_event::LenSz::Len(_, _) => {
476 return Err(DeserializeFailure::BreakInDefiniteLen.into())
477 }
478 cbor_event::LenSz::Indefinite => match raw.special()? {
479 cbor_event::Special::Break => break,
480 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
481 },
482 },
483 other_type => {
484 return Err(DeserializeFailure::UnexpectedKeyType(other_type).into())
485 }
486 }
487 read += 1;
488 }
489 read_len.finish()?;
490 Ok(Self {
491 metadata,
492 native_scripts,
493 plutus_v1_scripts,
494 plutus_v2_scripts,
495 plutus_v3_scripts,
496 encodings: Some(ConwayFormatAuxDataEncoding {
497 tag_encoding: Some(tag_encoding),
498 len_encoding,
499 orig_deser_order,
500 metadata_key_encoding,
501 native_scripts_key_encoding,
502 native_scripts_encoding,
503 plutus_v1_scripts_key_encoding,
504 plutus_v1_scripts_encoding,
505 plutus_v2_scripts_key_encoding,
506 plutus_v2_scripts_encoding,
507 plutus_v3_scripts_key_encoding,
508 plutus_v3_scripts_encoding,
509 }),
510 })
511 })()
512 .map_err(|e| e.annotate("ConwayFormatAuxData"))
513 }
514}
515
516impl Serialize for ShelleyMAFormatAuxData {
517 fn serialize<'se, W: Write>(
518 &self,
519 serializer: &'se mut Serializer<W>,
520 force_canonical: bool,
521 ) -> cbor_event::Result<&'se mut Serializer<W>> {
522 serializer.write_array_sz(
523 self.encodings
524 .as_ref()
525 .map(|encs| encs.len_encoding)
526 .unwrap_or_default()
527 .to_len_sz(2, force_canonical),
528 )?;
529 self.transaction_metadata
530 .serialize(serializer, force_canonical)?;
531 serializer.write_array_sz(
532 self.encodings
533 .as_ref()
534 .map(|encs| encs.auxiliary_scripts_encoding)
535 .unwrap_or_default()
536 .to_len_sz(self.auxiliary_scripts.len() as u64, force_canonical),
537 )?;
538 for element in self.auxiliary_scripts.iter() {
539 element.serialize(serializer, force_canonical)?;
540 }
541 self.encodings
542 .as_ref()
543 .map(|encs| encs.auxiliary_scripts_encoding)
544 .unwrap_or_default()
545 .end(serializer, force_canonical)?;
546 self.encodings
547 .as_ref()
548 .map(|encs| encs.len_encoding)
549 .unwrap_or_default()
550 .end(serializer, force_canonical)
551 }
552}
553
554impl Deserialize for ShelleyMAFormatAuxData {
555 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
556 let len = raw.array_sz()?;
557 let len_encoding: LenEncoding = len.into();
558 let mut read_len = CBORReadLen::new(len);
559 read_len.read_elems(2)?;
560 read_len.finish()?;
561 (|| -> Result<_, DeserializeError> {
562 let transaction_metadata = Metadata::deserialize(raw)
563 .map_err(|e: DeserializeError| e.annotate("transaction_metadata"))?;
564 let (auxiliary_scripts, auxiliary_scripts_encoding) =
565 (|| -> Result<_, DeserializeError> {
566 let mut auxiliary_scripts_arr = Vec::new();
567 let len = raw.array_sz()?;
568 let auxiliary_scripts_encoding = len.into();
569 while match len {
570 cbor_event::LenSz::Len(n, _) => (auxiliary_scripts_arr.len() as u64) < n,
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 auxiliary_scripts_arr.push(NativeScript::deserialize(raw)?);
578 }
579 Ok((auxiliary_scripts_arr, auxiliary_scripts_encoding))
580 })()
581 .map_err(|e| e.annotate("auxiliary_scripts"))?;
582 match len {
583 cbor_event::LenSz::Len(_, _) => (),
584 cbor_event::LenSz::Indefinite => match raw.special()? {
585 cbor_event::Special::Break => (),
586 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
587 },
588 }
589 Ok(ShelleyMAFormatAuxData {
590 transaction_metadata,
591 auxiliary_scripts,
592 encodings: Some(ShelleyMAFormatAuxDataEncoding {
593 len_encoding,
594 auxiliary_scripts_encoding,
595 }),
596 })
597 })()
598 .map_err(|e| e.annotate("ShelleyMAFormatAuxData"))
599 }
600}