cml_chain/plutus/
serialization.rs

1// This file was code-generated using an experimental CDDL to rust tool:
2// https://github.com/dcSpark/cddl-codegen
3
4use super::cbor_encodings::*;
5use super::*;
6use cbor_event::de::Deserializer;
7use cbor_event::se::Serializer;
8use cml_core::error::*;
9use cml_core::serialization::*;
10use std::collections::BTreeMap;
11use std::io::{BufRead, Seek, SeekFrom, Write};
12
13// PlutusData::Bytes uses this specific encoding:
14use crate::utils::{read_bounded_bytes, write_bounded_bytes};
15
16impl Serialize for CostModels {
17    fn serialize<'se, W: Write>(
18        &self,
19        serializer: &'se mut Serializer<W>,
20        force_canonical: bool,
21    ) -> cbor_event::Result<&'se mut Serializer<W>> {
22        serializer.write_map_sz(
23            self.encodings
24                .as_ref()
25                .map(|encs| encs.inner_encoding)
26                .unwrap_or_default()
27                .to_len_sz(self.inner.len() as u64, force_canonical),
28        )?;
29        let mut key_order = self
30            .inner
31            .iter()
32            .map(|(k, v)| {
33                let mut buf = cbor_event::se::Serializer::new_vec();
34                let inner_key_encoding = self
35                    .encodings
36                    .as_ref()
37                    .and_then(|encs| encs.inner_key_encodings.get(k))
38                    .cloned()
39                    .unwrap_or_default();
40                buf.write_unsigned_integer_sz(*k, fit_sz(*k, inner_key_encoding, force_canonical))?;
41                Ok((buf.finalize(), k, v))
42            })
43            .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
44        if force_canonical {
45            key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
46                match lhs_bytes.len().cmp(&rhs_bytes.len()) {
47                    std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
48                    diff_ord => diff_ord,
49                }
50            });
51        }
52        for (key_bytes, key, value) in key_order {
53            serializer.write_raw_bytes(&key_bytes)?;
54            let (inner_value_encoding, inner_value_elem_encodings) = self
55                .encodings
56                .as_ref()
57                .and_then(|encs| encs.inner_value_encodings.get(key))
58                .cloned()
59                .unwrap_or_else(|| (LenEncoding::default(), Vec::new()));
60            serializer.write_array_sz(
61                inner_value_encoding.to_len_sz(value.len() as u64, force_canonical),
62            )?;
63            for (i, element) in value.iter().enumerate() {
64                let inner_value_elem_encoding = inner_value_elem_encodings
65                    .get(i)
66                    .cloned()
67                    .unwrap_or_default();
68                if *element >= 0 {
69                    serializer.write_unsigned_integer_sz(
70                        *element as u64,
71                        fit_sz(*element as u64, inner_value_elem_encoding, force_canonical),
72                    )?;
73                } else {
74                    serializer.write_negative_integer_sz(
75                        *element as i128,
76                        fit_sz(
77                            (*element + 1).unsigned_abs(),
78                            inner_value_elem_encoding,
79                            force_canonical,
80                        ),
81                    )?;
82                }
83            }
84            inner_value_encoding.end(serializer, force_canonical)?;
85        }
86        self.encodings
87            .as_ref()
88            .map(|encs| encs.inner_encoding)
89            .unwrap_or_default()
90            .end(serializer, force_canonical)
91    }
92}
93
94impl Deserialize for CostModels {
95    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
96        let mut inner_table = OrderedHashMap::new();
97        let inner_len = raw.map_sz()?;
98        let inner_encoding = inner_len.into();
99        let mut inner_key_encodings = BTreeMap::new();
100        let mut inner_value_encodings = BTreeMap::new();
101        while match inner_len {
102            cbor_event::LenSz::Len(n, _) => (inner_table.len() as u64) < n,
103            cbor_event::LenSz::Indefinite => true,
104        } {
105            if raw.cbor_type()? == cbor_event::Type::Special {
106                assert_eq!(raw.special()?, cbor_event::Special::Break);
107                break;
108            }
109            let (inner_key, inner_key_encoding) =
110                raw.unsigned_integer_sz().map(|(x, enc)| (x, Some(enc)))?;
111            let mut inner_value_arr = Vec::new();
112            let len = raw.array_sz()?;
113            let inner_value_encoding = len.into();
114            let mut inner_value_elem_encodings = Vec::new();
115            while match len {
116                cbor_event::LenSz::Len(n, _) => (inner_value_arr.len() as u64) < n,
117                cbor_event::LenSz::Indefinite => true,
118            } {
119                if raw.cbor_type()? == cbor_event::Type::Special {
120                    assert_eq!(raw.special()?, cbor_event::Special::Break);
121                    break;
122                }
123                let (inner_value_elem, inner_value_elem_encoding) = match raw.cbor_type()? {
124                    cbor_event::Type::UnsignedInteger => {
125                        let (x, enc) = raw.unsigned_integer_sz()?;
126                        (x as i64, Some(enc))
127                    }
128                    _ => {
129                        let (x, enc) = raw.negative_integer_sz()?;
130                        (x as i64, Some(enc))
131                    }
132                };
133                inner_value_arr.push(inner_value_elem);
134                inner_value_elem_encodings.push(inner_value_elem_encoding);
135            }
136            let (inner_value, inner_value_encoding, inner_value_elem_encodings) = (
137                inner_value_arr,
138                inner_value_encoding,
139                inner_value_elem_encodings,
140            );
141            if inner_table.insert(inner_key, inner_value).is_some() {
142                return Err(DeserializeFailure::DuplicateKey(Key::Uint(inner_key)).into());
143            }
144            inner_key_encodings.insert(inner_key, inner_key_encoding);
145            inner_value_encodings.insert(
146                inner_key,
147                (inner_value_encoding, inner_value_elem_encodings),
148            );
149        }
150        let (inner, inner_encoding, inner_key_encodings, inner_value_encodings) = (
151            inner_table,
152            inner_encoding,
153            inner_key_encodings,
154            inner_value_encodings,
155        );
156        Ok(Self {
157            inner,
158            encodings: Some(CostModelsEncoding {
159                inner_encoding,
160                inner_key_encodings,
161                inner_value_encodings,
162            }),
163        })
164    }
165}
166
167impl Serialize for ExUnitPrices {
168    fn serialize<'se, W: Write>(
169        &self,
170        serializer: &'se mut Serializer<W>,
171        force_canonical: bool,
172    ) -> cbor_event::Result<&'se mut Serializer<W>> {
173        serializer.write_array_sz(
174            self.encodings
175                .as_ref()
176                .map(|encs| encs.len_encoding)
177                .unwrap_or_default()
178                .to_len_sz(2, force_canonical),
179        )?;
180        self.mem_price.serialize(serializer, force_canonical)?;
181        self.step_price.serialize(serializer, force_canonical)?;
182        self.encodings
183            .as_ref()
184            .map(|encs| encs.len_encoding)
185            .unwrap_or_default()
186            .end(serializer, force_canonical)
187    }
188}
189
190impl Deserialize for ExUnitPrices {
191    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
192        let len = raw.array_sz()?;
193        let len_encoding: LenEncoding = len.into();
194        let mut read_len = CBORReadLen::new(len);
195        read_len.read_elems(2)?;
196        read_len.finish()?;
197        (|| -> Result<_, DeserializeError> {
198            let mem_price = Rational::deserialize(raw)
199                .map_err(|e: DeserializeError| e.annotate("mem_price"))?;
200            let step_price = Rational::deserialize(raw)
201                .map_err(|e: DeserializeError| e.annotate("step_price"))?;
202            match len {
203                cbor_event::LenSz::Len(_, _) => (),
204                cbor_event::LenSz::Indefinite => match raw.special()? {
205                    cbor_event::Special::Break => (),
206                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
207                },
208            }
209            Ok(ExUnitPrices {
210                mem_price,
211                step_price,
212                encodings: Some(ExUnitPricesEncoding { len_encoding }),
213            })
214        })()
215        .map_err(|e| e.annotate("ExUnitPrices"))
216    }
217}
218
219impl Serialize for ExUnits {
220    fn serialize<'se, W: Write>(
221        &self,
222        serializer: &'se mut Serializer<W>,
223        force_canonical: bool,
224    ) -> cbor_event::Result<&'se mut Serializer<W>> {
225        serializer.write_array_sz(
226            self.encodings
227                .as_ref()
228                .map(|encs| encs.len_encoding)
229                .unwrap_or_default()
230                .to_len_sz(2, force_canonical),
231        )?;
232        serializer.write_unsigned_integer_sz(
233            self.mem,
234            fit_sz(
235                self.mem,
236                self.encodings
237                    .as_ref()
238                    .map(|encs| encs.mem_encoding)
239                    .unwrap_or_default(),
240                force_canonical,
241            ),
242        )?;
243        serializer.write_unsigned_integer_sz(
244            self.steps,
245            fit_sz(
246                self.steps,
247                self.encodings
248                    .as_ref()
249                    .map(|encs| encs.steps_encoding)
250                    .unwrap_or_default(),
251                force_canonical,
252            ),
253        )?;
254        self.encodings
255            .as_ref()
256            .map(|encs| encs.len_encoding)
257            .unwrap_or_default()
258            .end(serializer, force_canonical)
259    }
260}
261
262impl Deserialize for ExUnits {
263    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
264        let len = raw.array_sz()?;
265        let len_encoding: LenEncoding = len.into();
266        let mut read_len = CBORReadLen::new(len);
267        read_len.read_elems(2)?;
268        read_len.finish()?;
269        (|| -> Result<_, DeserializeError> {
270            let (mem, mem_encoding) = raw
271                .unsigned_integer_sz()
272                .map_err(Into::<DeserializeError>::into)
273                .map(|(x, enc)| (x, Some(enc)))
274                .map_err(|e: DeserializeError| e.annotate("mem"))?;
275            let (steps, steps_encoding) = raw
276                .unsigned_integer_sz()
277                .map_err(Into::<DeserializeError>::into)
278                .map(|(x, enc)| (x, Some(enc)))
279                .map_err(|e: DeserializeError| e.annotate("steps"))?;
280            match len {
281                cbor_event::LenSz::Len(_, _) => (),
282                cbor_event::LenSz::Indefinite => match raw.special()? {
283                    cbor_event::Special::Break => (),
284                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
285                },
286            }
287            Ok(ExUnits {
288                mem,
289                steps,
290                encodings: Some(ExUnitsEncoding {
291                    len_encoding,
292                    mem_encoding,
293                    steps_encoding,
294                }),
295            })
296        })()
297        .map_err(|e| e.annotate("ExUnits"))
298    }
299}
300
301impl Serialize for LegacyRedeemer {
302    fn serialize<'se, W: Write>(
303        &self,
304        serializer: &'se mut Serializer<W>,
305        force_canonical: bool,
306    ) -> cbor_event::Result<&'se mut Serializer<W>> {
307        serializer.write_array_sz(
308            self.encodings
309                .as_ref()
310                .map(|encs| encs.len_encoding)
311                .unwrap_or_default()
312                .to_len_sz(4, force_canonical),
313        )?;
314        match &self.tag {
315            RedeemerTag::Spend => serializer.write_unsigned_integer_sz(
316                0u64,
317                fit_sz(
318                    0u64,
319                    self.encodings
320                        .as_ref()
321                        .map(|encs| encs.tag_encoding)
322                        .unwrap_or_default(),
323                    force_canonical,
324                ),
325            ),
326            RedeemerTag::Mint => serializer.write_unsigned_integer_sz(
327                1u64,
328                fit_sz(
329                    1u64,
330                    self.encodings
331                        .as_ref()
332                        .map(|encs| encs.tag_encoding)
333                        .unwrap_or_default(),
334                    force_canonical,
335                ),
336            ),
337            RedeemerTag::Cert => serializer.write_unsigned_integer_sz(
338                2u64,
339                fit_sz(
340                    2u64,
341                    self.encodings
342                        .as_ref()
343                        .map(|encs| encs.tag_encoding)
344                        .unwrap_or_default(),
345                    force_canonical,
346                ),
347            ),
348            RedeemerTag::Reward => serializer.write_unsigned_integer_sz(
349                3u64,
350                fit_sz(
351                    3u64,
352                    self.encodings
353                        .as_ref()
354                        .map(|encs| encs.tag_encoding)
355                        .unwrap_or_default(),
356                    force_canonical,
357                ),
358            ),
359            RedeemerTag::Voting => serializer.write_unsigned_integer_sz(
360                4u64,
361                fit_sz(
362                    4u64,
363                    self.encodings
364                        .as_ref()
365                        .map(|encs| encs.tag_encoding)
366                        .unwrap_or_default(),
367                    force_canonical,
368                ),
369            ),
370            RedeemerTag::Proposing => serializer.write_unsigned_integer_sz(
371                5u64,
372                fit_sz(
373                    5u64,
374                    self.encodings
375                        .as_ref()
376                        .map(|encs| encs.tag_encoding)
377                        .unwrap_or_default(),
378                    force_canonical,
379                ),
380            ),
381        }?;
382        serializer.write_unsigned_integer_sz(
383            self.index,
384            fit_sz(
385                self.index,
386                self.encodings
387                    .as_ref()
388                    .map(|encs| encs.index_encoding)
389                    .unwrap_or_default(),
390                force_canonical,
391            ),
392        )?;
393        self.data.serialize(serializer, force_canonical)?;
394        self.ex_units.serialize(serializer, force_canonical)?;
395        self.encodings
396            .as_ref()
397            .map(|encs| encs.len_encoding)
398            .unwrap_or_default()
399            .end(serializer, force_canonical)
400    }
401}
402
403impl Deserialize for LegacyRedeemer {
404    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
405        let len = raw.array_sz()?;
406        let len_encoding: LenEncoding = len.into();
407        let mut read_len = CBORReadLen::new(len);
408        read_len.read_elems(4)?;
409        read_len.finish()?;
410        (|| -> Result<_, DeserializeError> {
411            let (tag, tag_encoding) = (|| -> Result<_, DeserializeError> {
412                let initial_position = raw.as_mut_ref().stream_position().unwrap();
413                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
414                    let (spend_value, spend_encoding) = raw.unsigned_integer_sz()?;
415                    if spend_value != 0 {
416                        return Err(DeserializeFailure::FixedValueMismatch {
417                            found: Key::Uint(spend_value),
418                            expected: Key::Uint(0),
419                        }
420                        .into());
421                    }
422                    Ok(Some(spend_encoding))
423                })(raw);
424                match deser_variant {
425                    Ok(tag_encoding) => return Ok((RedeemerTag::Spend, tag_encoding)),
426                    Err(_) => raw
427                        .as_mut_ref()
428                        .seek(SeekFrom::Start(initial_position))
429                        .unwrap(),
430                };
431                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
432                    let (mint_value, mint_encoding) = raw.unsigned_integer_sz()?;
433                    if mint_value != 1 {
434                        return Err(DeserializeFailure::FixedValueMismatch {
435                            found: Key::Uint(mint_value),
436                            expected: Key::Uint(1),
437                        }
438                        .into());
439                    }
440                    Ok(Some(mint_encoding))
441                })(raw);
442                match deser_variant {
443                    Ok(tag_encoding) => return Ok((RedeemerTag::Mint, tag_encoding)),
444                    Err(_) => raw
445                        .as_mut_ref()
446                        .seek(SeekFrom::Start(initial_position))
447                        .unwrap(),
448                };
449                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
450                    let (cert_value, cert_encoding) = raw.unsigned_integer_sz()?;
451                    if cert_value != 2 {
452                        return Err(DeserializeFailure::FixedValueMismatch {
453                            found: Key::Uint(cert_value),
454                            expected: Key::Uint(2),
455                        }
456                        .into());
457                    }
458                    Ok(Some(cert_encoding))
459                })(raw);
460                match deser_variant {
461                    Ok(tag_encoding) => return Ok((RedeemerTag::Cert, tag_encoding)),
462                    Err(_) => raw
463                        .as_mut_ref()
464                        .seek(SeekFrom::Start(initial_position))
465                        .unwrap(),
466                };
467                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
468                    let (reward_value, reward_encoding) = raw.unsigned_integer_sz()?;
469                    if reward_value != 3 {
470                        return Err(DeserializeFailure::FixedValueMismatch {
471                            found: Key::Uint(reward_value),
472                            expected: Key::Uint(3),
473                        }
474                        .into());
475                    }
476                    Ok(Some(reward_encoding))
477                })(raw);
478                match deser_variant {
479                    Ok(tag_encoding) => return Ok((RedeemerTag::Reward, tag_encoding)),
480                    Err(_) => raw
481                        .as_mut_ref()
482                        .seek(SeekFrom::Start(initial_position))
483                        .unwrap(),
484                };
485                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
486                    let (voting_value, voting_encoding) = raw.unsigned_integer_sz()?;
487                    if voting_value != 4 {
488                        return Err(DeserializeFailure::FixedValueMismatch {
489                            found: Key::Uint(voting_value),
490                            expected: Key::Uint(4),
491                        }
492                        .into());
493                    }
494                    Ok(Some(voting_encoding))
495                })(raw);
496                match deser_variant {
497                    Ok(tag_encoding) => return Ok((RedeemerTag::Voting, tag_encoding)),
498                    Err(_) => raw
499                        .as_mut_ref()
500                        .seek(SeekFrom::Start(initial_position))
501                        .unwrap(),
502                };
503                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
504                    let (proposing_value, proposing_encoding) = raw.unsigned_integer_sz()?;
505                    if proposing_value != 5 {
506                        return Err(DeserializeFailure::FixedValueMismatch {
507                            found: Key::Uint(proposing_value),
508                            expected: Key::Uint(5),
509                        }
510                        .into());
511                    }
512                    Ok(Some(proposing_encoding))
513                })(raw);
514                match deser_variant {
515                    Ok(tag_encoding) => return Ok((RedeemerTag::Proposing, tag_encoding)),
516                    Err(_) => raw
517                        .as_mut_ref()
518                        .seek(SeekFrom::Start(initial_position))
519                        .unwrap(),
520                };
521                Err(DeserializeError::new(
522                    "RedeemerTag",
523                    DeserializeFailure::NoVariantMatched,
524                ))
525            })()
526            .map_err(|e| e.annotate("tag"))?;
527            let (index, index_encoding) = raw
528                .unsigned_integer_sz()
529                .map_err(Into::<DeserializeError>::into)
530                .map(|(x, enc)| (x, Some(enc)))
531                .map_err(|e: DeserializeError| e.annotate("index"))?;
532            let data =
533                PlutusData::deserialize(raw).map_err(|e: DeserializeError| e.annotate("data"))?;
534            let ex_units =
535                ExUnits::deserialize(raw).map_err(|e: DeserializeError| e.annotate("ex_units"))?;
536            match len {
537                cbor_event::LenSz::Len(_, _) => (),
538                cbor_event::LenSz::Indefinite => match raw.special()? {
539                    cbor_event::Special::Break => (),
540                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
541                },
542            }
543            Ok(LegacyRedeemer {
544                tag,
545                index,
546                data,
547                ex_units,
548                encodings: Some(LegacyRedeemerEncoding {
549                    len_encoding,
550                    tag_encoding,
551                    index_encoding,
552                }),
553            })
554        })()
555        .map_err(|e| e.annotate("LegacyRedeemer"))
556    }
557}
558
559impl Serialize for PlutusData {
560    fn serialize<'se, W: Write>(
561        &self,
562        serializer: &'se mut Serializer<W>,
563        force_canonical: bool,
564    ) -> cbor_event::Result<&'se mut Serializer<W>> {
565        match self {
566            PlutusData::ConstrPlutusData(constr_plutus_data) => {
567                constr_plutus_data.serialize(serializer, force_canonical)
568            }
569            PlutusData::Map(map) => map.serialize(serializer, force_canonical),
570            PlutusData::List {
571                list,
572                list_encoding,
573            } => {
574                serializer
575                    .write_array_sz(list_encoding.to_len_sz(list.len() as u64, force_canonical))?;
576                for element in list.iter() {
577                    element.serialize(serializer, force_canonical)?;
578                }
579                list_encoding.end(serializer, force_canonical)
580            }
581            PlutusData::Integer(big_int) => big_int.serialize(serializer, force_canonical),
582            // hand-written
583            PlutusData::Bytes {
584                bytes,
585                bytes_encoding,
586            } => write_bounded_bytes(serializer, bytes, bytes_encoding, force_canonical),
587        }
588    }
589}
590
591impl Deserialize for PlutusData {
592    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
593        (|| -> Result<_, DeserializeError> {
594            // hand-coded based on generated code
595            // 1) we use bounded bytes not
596            // 2) to give better errors / direct branch on cbor_type()?
597            match raw.cbor_type()? {
598                cbor_event::Type::Tag => {
599                    // could be large BigInteger or ConstrPlutusData so check tag to see which it is
600                    let initial_position = raw.as_mut_ref().stream_position().unwrap();
601                    let tag = raw.tag()?;
602                    raw.as_mut_ref()
603                        .seek(SeekFrom::Start(initial_position))
604                        .unwrap();
605                    if tag == 2 || tag == 3 {
606                        BigInteger::deserialize(raw)
607                            .map(Self::Integer)
608                            .map_err(|e| e.annotate("Integer"))
609                    } else {
610                        ConstrPlutusData::deserialize(raw)
611                            .map(Self::ConstrPlutusData)
612                            .map_err(|e| e.annotate("ConstrPlutusData"))
613                    }
614                }
615                cbor_event::Type::Map => PlutusMap::deserialize(raw)
616                    .map(Self::Map)
617                    .map_err(|e| e.annotate("Map")),
618                cbor_event::Type::Array => {
619                    (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
620                        let mut list_arr = Vec::new();
621                        let len = raw.array_sz()?;
622                        let list_encoding = len.into();
623                        while match len {
624                            cbor_event::LenSz::Len(n, _) => (list_arr.len() as u64) < n,
625                            cbor_event::LenSz::Indefinite => true,
626                        } {
627                            if raw.cbor_type()? == cbor_event::Type::Special {
628                                assert_eq!(raw.special()?, cbor_event::Special::Break);
629                                break;
630                            }
631                            list_arr.push(PlutusData::deserialize(raw)?);
632                        }
633                        Ok(Self::List {
634                            list: list_arr,
635                            list_encoding,
636                        })
637                    })(raw)
638                    .map_err(|e| e.annotate("List"))
639                }
640                cbor_event::Type::UnsignedInteger | cbor_event::Type::NegativeInteger => {
641                    BigInteger::deserialize(raw)
642                        .map(Self::Integer)
643                        .map_err(|e| e.annotate("Integer"))
644                }
645                // hand-written 100% since the format is not just arbitrary CBOR bytes
646                cbor_event::Type::Bytes => read_bounded_bytes(raw)
647                    .map(|(bytes, bytes_encoding)| Self::Bytes {
648                        bytes,
649                        bytes_encoding,
650                    })
651                    .map_err(|e| e.annotate("Bytes")),
652                _ => Err(DeserializeFailure::NoVariantMatched.into()),
653            }
654        })()
655        .map_err(|e| e.annotate("PlutusData"))
656    }
657}
658
659impl Serialize for PlutusV1Script {
660    fn serialize<'se, W: Write>(
661        &self,
662        serializer: &'se mut Serializer<W>,
663        force_canonical: bool,
664    ) -> cbor_event::Result<&'se mut Serializer<W>> {
665        serializer.write_bytes_sz(
666            &self.inner,
667            self.encodings
668                .as_ref()
669                .map(|encs| encs.inner_encoding.clone())
670                .unwrap_or_default()
671                .to_str_len_sz(self.inner.len() as u64, force_canonical),
672        )
673    }
674}
675
676impl Deserialize for PlutusV1Script {
677    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
678        let (inner, inner_encoding) = raw
679            .bytes_sz()
680            .map(|(bytes, enc)| (bytes, StringEncoding::from(enc)))?;
681        Ok(Self {
682            inner,
683            encodings: Some(PlutusV1ScriptEncoding { inner_encoding }),
684        })
685    }
686}
687
688impl Serialize for PlutusV2Script {
689    fn serialize<'se, W: Write>(
690        &self,
691        serializer: &'se mut Serializer<W>,
692        force_canonical: bool,
693    ) -> cbor_event::Result<&'se mut Serializer<W>> {
694        serializer.write_bytes_sz(
695            &self.inner,
696            self.encodings
697                .as_ref()
698                .map(|encs| encs.inner_encoding.clone())
699                .unwrap_or_default()
700                .to_str_len_sz(self.inner.len() as u64, force_canonical),
701        )
702    }
703}
704
705impl Deserialize for PlutusV2Script {
706    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
707        let (inner, inner_encoding) = raw
708            .bytes_sz()
709            .map(|(bytes, enc)| (bytes, StringEncoding::from(enc)))?;
710        Ok(Self {
711            inner,
712            encodings: Some(PlutusV2ScriptEncoding { inner_encoding }),
713        })
714    }
715}
716
717impl Serialize for PlutusV3Script {
718    fn serialize<'se, W: Write>(
719        &self,
720        serializer: &'se mut Serializer<W>,
721        force_canonical: bool,
722    ) -> cbor_event::Result<&'se mut Serializer<W>> {
723        serializer.write_bytes_sz(
724            &self.inner,
725            self.encodings
726                .as_ref()
727                .map(|encs| encs.inner_encoding.clone())
728                .unwrap_or_default()
729                .to_str_len_sz(self.inner.len() as u64, force_canonical),
730        )
731    }
732}
733
734impl Deserialize for PlutusV3Script {
735    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
736        let (inner, inner_encoding) = raw
737            .bytes_sz()
738            .map(|(bytes, enc)| (bytes, StringEncoding::from(enc)))?;
739        Ok(Self {
740            inner,
741            encodings: Some(PlutusV3ScriptEncoding { inner_encoding }),
742        })
743    }
744}
745
746impl Serialize for RedeemerKey {
747    fn serialize<'se, W: Write>(
748        &self,
749        serializer: &'se mut Serializer<W>,
750        force_canonical: bool,
751    ) -> cbor_event::Result<&'se mut Serializer<W>> {
752        serializer.write_array_sz(
753            self.encodings
754                .as_ref()
755                .map(|encs| encs.len_encoding)
756                .unwrap_or_default()
757                .to_len_sz(2, force_canonical),
758        )?;
759        match &self.tag {
760            RedeemerTag::Spend => serializer.write_unsigned_integer_sz(
761                0u64,
762                fit_sz(
763                    0u64,
764                    self.encodings
765                        .as_ref()
766                        .map(|encs| encs.tag_encoding)
767                        .unwrap_or_default(),
768                    force_canonical,
769                ),
770            ),
771            RedeemerTag::Mint => serializer.write_unsigned_integer_sz(
772                1u64,
773                fit_sz(
774                    1u64,
775                    self.encodings
776                        .as_ref()
777                        .map(|encs| encs.tag_encoding)
778                        .unwrap_or_default(),
779                    force_canonical,
780                ),
781            ),
782            RedeemerTag::Cert => serializer.write_unsigned_integer_sz(
783                2u64,
784                fit_sz(
785                    2u64,
786                    self.encodings
787                        .as_ref()
788                        .map(|encs| encs.tag_encoding)
789                        .unwrap_or_default(),
790                    force_canonical,
791                ),
792            ),
793            RedeemerTag::Reward => serializer.write_unsigned_integer_sz(
794                3u64,
795                fit_sz(
796                    3u64,
797                    self.encodings
798                        .as_ref()
799                        .map(|encs| encs.tag_encoding)
800                        .unwrap_or_default(),
801                    force_canonical,
802                ),
803            ),
804            RedeemerTag::Voting => serializer.write_unsigned_integer_sz(
805                4u64,
806                fit_sz(
807                    4u64,
808                    self.encodings
809                        .as_ref()
810                        .map(|encs| encs.tag_encoding)
811                        .unwrap_or_default(),
812                    force_canonical,
813                ),
814            ),
815            RedeemerTag::Proposing => serializer.write_unsigned_integer_sz(
816                5u64,
817                fit_sz(
818                    5u64,
819                    self.encodings
820                        .as_ref()
821                        .map(|encs| encs.tag_encoding)
822                        .unwrap_or_default(),
823                    force_canonical,
824                ),
825            ),
826        }?;
827        serializer.write_unsigned_integer_sz(
828            self.index,
829            fit_sz(
830                self.index,
831                self.encodings
832                    .as_ref()
833                    .map(|encs| encs.index_encoding)
834                    .unwrap_or_default(),
835                force_canonical,
836            ),
837        )?;
838        self.encodings
839            .as_ref()
840            .map(|encs| encs.len_encoding)
841            .unwrap_or_default()
842            .end(serializer, force_canonical)
843    }
844}
845
846impl Deserialize for RedeemerKey {
847    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
848        let len = raw.array_sz()?;
849        let len_encoding: LenEncoding = len.into();
850        let mut read_len = CBORReadLen::new(len);
851        read_len.read_elems(2)?;
852        read_len.finish()?;
853        (|| -> Result<_, DeserializeError> {
854            let (tag, tag_encoding) = (|| -> Result<_, DeserializeError> {
855                let initial_position = raw.as_mut_ref().stream_position().unwrap();
856                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
857                    let (spend_value, spend_encoding) = raw.unsigned_integer_sz()?;
858                    if spend_value != 0 {
859                        return Err(DeserializeFailure::FixedValueMismatch {
860                            found: Key::Uint(spend_value),
861                            expected: Key::Uint(0),
862                        }
863                        .into());
864                    }
865                    Ok(Some(spend_encoding))
866                })(raw);
867                match deser_variant {
868                    Ok(tag_encoding) => return Ok((RedeemerTag::Spend, tag_encoding)),
869                    Err(_) => raw
870                        .as_mut_ref()
871                        .seek(SeekFrom::Start(initial_position))
872                        .unwrap(),
873                };
874                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
875                    let (mint_value, mint_encoding) = raw.unsigned_integer_sz()?;
876                    if mint_value != 1 {
877                        return Err(DeserializeFailure::FixedValueMismatch {
878                            found: Key::Uint(mint_value),
879                            expected: Key::Uint(1),
880                        }
881                        .into());
882                    }
883                    Ok(Some(mint_encoding))
884                })(raw);
885                match deser_variant {
886                    Ok(tag_encoding) => return Ok((RedeemerTag::Mint, tag_encoding)),
887                    Err(_) => raw
888                        .as_mut_ref()
889                        .seek(SeekFrom::Start(initial_position))
890                        .unwrap(),
891                };
892                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
893                    let (cert_value, cert_encoding) = raw.unsigned_integer_sz()?;
894                    if cert_value != 2 {
895                        return Err(DeserializeFailure::FixedValueMismatch {
896                            found: Key::Uint(cert_value),
897                            expected: Key::Uint(2),
898                        }
899                        .into());
900                    }
901                    Ok(Some(cert_encoding))
902                })(raw);
903                match deser_variant {
904                    Ok(tag_encoding) => return Ok((RedeemerTag::Cert, tag_encoding)),
905                    Err(_) => raw
906                        .as_mut_ref()
907                        .seek(SeekFrom::Start(initial_position))
908                        .unwrap(),
909                };
910                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
911                    let (reward_value, reward_encoding) = raw.unsigned_integer_sz()?;
912                    if reward_value != 3 {
913                        return Err(DeserializeFailure::FixedValueMismatch {
914                            found: Key::Uint(reward_value),
915                            expected: Key::Uint(3),
916                        }
917                        .into());
918                    }
919                    Ok(Some(reward_encoding))
920                })(raw);
921                match deser_variant {
922                    Ok(tag_encoding) => return Ok((RedeemerTag::Reward, tag_encoding)),
923                    Err(_) => raw
924                        .as_mut_ref()
925                        .seek(SeekFrom::Start(initial_position))
926                        .unwrap(),
927                };
928                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
929                    let (voting_value, voting_encoding) = raw.unsigned_integer_sz()?;
930                    if voting_value != 4 {
931                        return Err(DeserializeFailure::FixedValueMismatch {
932                            found: Key::Uint(voting_value),
933                            expected: Key::Uint(4),
934                        }
935                        .into());
936                    }
937                    Ok(Some(voting_encoding))
938                })(raw);
939                match deser_variant {
940                    Ok(tag_encoding) => return Ok((RedeemerTag::Voting, tag_encoding)),
941                    Err(_) => raw
942                        .as_mut_ref()
943                        .seek(SeekFrom::Start(initial_position))
944                        .unwrap(),
945                };
946                let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
947                    let (proposing_value, proposing_encoding) = raw.unsigned_integer_sz()?;
948                    if proposing_value != 5 {
949                        return Err(DeserializeFailure::FixedValueMismatch {
950                            found: Key::Uint(proposing_value),
951                            expected: Key::Uint(5),
952                        }
953                        .into());
954                    }
955                    Ok(Some(proposing_encoding))
956                })(raw);
957                match deser_variant {
958                    Ok(tag_encoding) => return Ok((RedeemerTag::Proposing, tag_encoding)),
959                    Err(_) => raw
960                        .as_mut_ref()
961                        .seek(SeekFrom::Start(initial_position))
962                        .unwrap(),
963                };
964                Err(DeserializeError::new(
965                    "RedeemerTag",
966                    DeserializeFailure::NoVariantMatched,
967                ))
968            })()
969            .map_err(|e| e.annotate("tag"))?;
970            let (index, index_encoding) = raw
971                .unsigned_integer_sz()
972                .map_err(Into::<DeserializeError>::into)
973                .map(|(x, enc)| (x, Some(enc)))
974                .map_err(|e: DeserializeError| e.annotate("index"))?;
975            match len {
976                cbor_event::LenSz::Len(_, _) => (),
977                cbor_event::LenSz::Indefinite => match raw.special()? {
978                    cbor_event::Special::Break => (),
979                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
980                },
981            }
982            Ok(RedeemerKey {
983                tag,
984                index,
985                encodings: Some(RedeemerKeyEncoding {
986                    len_encoding,
987                    tag_encoding,
988                    index_encoding,
989                }),
990            })
991        })()
992        .map_err(|e| e.annotate("RedeemerKey"))
993    }
994}
995
996impl Serialize for RedeemerVal {
997    fn serialize<'se, W: Write>(
998        &self,
999        serializer: &'se mut Serializer<W>,
1000        force_canonical: bool,
1001    ) -> cbor_event::Result<&'se mut Serializer<W>> {
1002        serializer.write_array_sz(
1003            self.encodings
1004                .as_ref()
1005                .map(|encs| encs.len_encoding)
1006                .unwrap_or_default()
1007                .to_len_sz(2, force_canonical),
1008        )?;
1009        self.data.serialize(serializer, force_canonical)?;
1010        self.ex_units.serialize(serializer, force_canonical)?;
1011        self.encodings
1012            .as_ref()
1013            .map(|encs| encs.len_encoding)
1014            .unwrap_or_default()
1015            .end(serializer, force_canonical)
1016    }
1017}
1018
1019impl Deserialize for RedeemerVal {
1020    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1021        let len = raw.array_sz()?;
1022        let len_encoding: LenEncoding = len.into();
1023        let mut read_len = CBORReadLen::new(len);
1024        read_len.read_elems(2)?;
1025        read_len.finish()?;
1026        (|| -> Result<_, DeserializeError> {
1027            let data =
1028                PlutusData::deserialize(raw).map_err(|e: DeserializeError| e.annotate("data"))?;
1029            let ex_units =
1030                ExUnits::deserialize(raw).map_err(|e: DeserializeError| e.annotate("ex_units"))?;
1031            match len {
1032                cbor_event::LenSz::Len(_, _) => (),
1033                cbor_event::LenSz::Indefinite => match raw.special()? {
1034                    cbor_event::Special::Break => (),
1035                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1036                },
1037            }
1038            Ok(RedeemerVal {
1039                data,
1040                ex_units,
1041                encodings: Some(RedeemerValEncoding { len_encoding }),
1042            })
1043        })()
1044        .map_err(|e| e.annotate("RedeemerVal"))
1045    }
1046}
1047
1048impl Serialize for Redeemers {
1049    fn serialize<'se, W: Write>(
1050        &self,
1051        serializer: &'se mut Serializer<W>,
1052        force_canonical: bool,
1053    ) -> cbor_event::Result<&'se mut Serializer<W>> {
1054        match self {
1055            Redeemers::ArrLegacyRedeemer {
1056                arr_legacy_redeemer,
1057                arr_legacy_redeemer_encoding,
1058            } => {
1059                serializer.write_array_sz(
1060                    arr_legacy_redeemer_encoding
1061                        .to_len_sz(arr_legacy_redeemer.len() as u64, force_canonical),
1062                )?;
1063                for element in arr_legacy_redeemer.iter() {
1064                    element.serialize(serializer, force_canonical)?;
1065                }
1066                arr_legacy_redeemer_encoding.end(serializer, force_canonical)
1067            }
1068            Redeemers::MapRedeemerKeyToRedeemerVal {
1069                map_redeemer_key_to_redeemer_val,
1070                map_redeemer_key_to_redeemer_val_encoding,
1071            } => {
1072                serializer.write_map_sz(map_redeemer_key_to_redeemer_val_encoding.to_len_sz(
1073                    map_redeemer_key_to_redeemer_val.len() as u64,
1074                    force_canonical,
1075                ))?;
1076                let mut key_order = map_redeemer_key_to_redeemer_val
1077                    .iter()
1078                    .map(|(k, v)| {
1079                        let mut buf = cbor_event::se::Serializer::new_vec();
1080                        k.serialize(&mut buf, force_canonical)?;
1081                        Ok((buf.finalize(), k, v))
1082                    })
1083                    .collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
1084                if force_canonical {
1085                    key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
1086                        match lhs_bytes.len().cmp(&rhs_bytes.len()) {
1087                            std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
1088                            diff_ord => diff_ord,
1089                        }
1090                    });
1091                }
1092                for (key_bytes, _key, value) in key_order {
1093                    serializer.write_raw_bytes(&key_bytes)?;
1094                    value.serialize(serializer, force_canonical)?;
1095                }
1096                map_redeemer_key_to_redeemer_val_encoding.end(serializer, force_canonical)
1097            }
1098        }
1099    }
1100}
1101
1102impl Deserialize for Redeemers {
1103    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1104        (|| -> Result<_, DeserializeError> {
1105            match raw.cbor_type()? {
1106                cbor_event::Type::Array => {
1107                    let mut arr_legacy_redeemer_arr = Vec::new();
1108                    let len = raw.array_sz()?;
1109                    let arr_legacy_redeemer_encoding = len.into();
1110                    while match len {
1111                        cbor_event::LenSz::Len(n, _) => (arr_legacy_redeemer_arr.len() as u64) < n,
1112                        cbor_event::LenSz::Indefinite => true,
1113                    } {
1114                        if raw.cbor_type()? == cbor_event::Type::Special {
1115                            assert_eq!(raw.special()?, cbor_event::Special::Break);
1116                            break;
1117                        }
1118                        arr_legacy_redeemer_arr.push(LegacyRedeemer::deserialize(raw)?);
1119                    }
1120                    let (arr_legacy_redeemer, arr_legacy_redeemer_encoding) =
1121                        (arr_legacy_redeemer_arr, arr_legacy_redeemer_encoding);
1122                    Ok(Self::ArrLegacyRedeemer {
1123                        arr_legacy_redeemer,
1124                        arr_legacy_redeemer_encoding,
1125                    })
1126                }
1127                cbor_event::Type::Map => {
1128                    let mut map_redeemer_key_to_redeemer_val_table = OrderedHashMap::new();
1129                    let map_redeemer_key_to_redeemer_val_len = raw.map_sz()?;
1130                    let map_redeemer_key_to_redeemer_val_encoding =
1131                        map_redeemer_key_to_redeemer_val_len.into();
1132                    while match map_redeemer_key_to_redeemer_val_len {
1133                        cbor_event::LenSz::Len(n, _) => {
1134                            (map_redeemer_key_to_redeemer_val_table.len() as u64) < n
1135                        }
1136                        cbor_event::LenSz::Indefinite => true,
1137                    } {
1138                        if raw.cbor_type()? == cbor_event::Type::Special {
1139                            assert_eq!(raw.special()?, cbor_event::Special::Break);
1140                            break;
1141                        }
1142                        let map_redeemer_key_to_redeemer_val_key = RedeemerKey::deserialize(raw)?;
1143                        let map_redeemer_key_to_redeemer_val_value = RedeemerVal::deserialize(raw)?;
1144                        if map_redeemer_key_to_redeemer_val_table
1145                            .insert(
1146                                map_redeemer_key_to_redeemer_val_key.clone(),
1147                                map_redeemer_key_to_redeemer_val_value,
1148                            )
1149                            .is_some()
1150                        {
1151                            return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
1152                                "some complicated/unsupported type",
1153                            )))
1154                            .into());
1155                        }
1156                    }
1157                    let (
1158                        map_redeemer_key_to_redeemer_val,
1159                        map_redeemer_key_to_redeemer_val_encoding,
1160                    ) = (
1161                        map_redeemer_key_to_redeemer_val_table,
1162                        map_redeemer_key_to_redeemer_val_encoding,
1163                    );
1164                    Ok(Self::MapRedeemerKeyToRedeemerVal {
1165                        map_redeemer_key_to_redeemer_val,
1166                        map_redeemer_key_to_redeemer_val_encoding,
1167                    })
1168                }
1169                _ => Err(DeserializeError::new(
1170                    "Redeemers",
1171                    DeserializeFailure::NoVariantMatched,
1172                )),
1173            }
1174        })()
1175        .map_err(|e| e.annotate("Redeemers"))
1176    }
1177}
cml_chain/plutus/serialization.rs

cml_chain/plutus/
serialization.rs
