cardano_serialization_lib/serialization/plutus/
redeemer.rs

1use crate::*;
2use crate::serialization::utils::check_len_indefinite;
3
4impl cbor_event::se::Serialize for Redeemer {
5    fn serialize<'se, W: Write>(
6        &self,
7        serializer: &'se mut Serializer<W>,
8    ) -> cbor_event::Result<&'se mut Serializer<W>> {
9        self.serialize_as_array_item(serializer)?;
10        Ok(serializer)
11    }
12}
13
14impl Redeemer {
15    pub(crate) fn serialize_as_array_item<'se, W: Write>(
16        &self,
17        serializer: &'se mut Serializer<W>,
18    ) -> cbor_event::Result<&'se mut Serializer<W>> {
19        serializer.write_array(Len::Len(4))?;
20        self.tag.serialize(serializer)?;
21        self.index.serialize(serializer)?;
22        self.data.serialize(serializer)?;
23        self.ex_units.serialize(serializer)?;
24        Ok(serializer)
25    }
26
27    pub(crate) fn serialize_as_map_item<'se, W: Write>(
28        &self,
29        serializer: &'se mut Serializer<W>,
30    ) -> cbor_event::Result<&'se mut Serializer<W>> {
31        self.serialize_as_map_key(serializer)?;
32        self.serialize_as_map_value(serializer)
33    }
34    fn serialize_as_map_key<'se, W: Write>(
35        &self,
36        serializer: &'se mut Serializer<W>,
37    ) -> cbor_event::Result<&'se mut Serializer<W>> {
38        serializer.write_array(Len::Len(2))?;
39        self.tag.serialize(serializer)?;
40        self.index.serialize(serializer)?;
41        Ok(serializer)
42    }
43
44    fn serialize_as_map_value<'se, W: Write>(
45        &self,
46        serializer: &'se mut Serializer<W>,
47    ) -> cbor_event::Result<&'se mut Serializer<W>> {
48        serializer.write_array(Len::Len(2))?;
49        self.data.serialize(serializer)?;
50        self.ex_units.serialize(serializer)?;
51        Ok(serializer)
52    }
53}
54
55impl Deserialize for Redeemer {
56    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
57        Self::deserialize_as_array_item(raw).map_err(|e| e.annotate("Redeemer"))
58    }
59}
60
61impl Redeemer {
62    pub(crate) fn deserialize_as_array_item<R: BufRead + Seek>(
63        raw: &mut Deserializer<R>,
64    ) -> Result<Self, DeserializeError> {
65        let len = raw.array()?;
66        let mut read_len = CBORReadLen::new(len);
67        read_len.read_elems(4)?;
68        let tag = (|| -> Result<_, DeserializeError> { Ok(RedeemerTag::deserialize(raw)?) })()
69            .map_err(|e| e.annotate("tag"))?;
70        let index = (|| -> Result<_, DeserializeError> { Ok(BigNum::deserialize(raw)?) })()
71            .map_err(|e| e.annotate("index"))?;
72        let data = (|| -> Result<_, DeserializeError> { Ok(PlutusData::deserialize(raw)?) })()
73            .map_err(|e| e.annotate("data"))?;
74        let ex_units = (|| -> Result<_, DeserializeError> { Ok(ExUnits::deserialize(raw)?) })()
75            .map_err(|e| e.annotate("ex_units"))?;
76        check_len_indefinite(raw, len)?;
77        Ok(Redeemer {
78            tag,
79            index,
80            data,
81            ex_units,
82        })
83    }
84
85    pub(crate) fn deserialize_as_map_item<R: BufRead + Seek>(
86        raw: &mut Deserializer<R>,
87    ) -> Result<Self, DeserializeError> {
88        let (tag, index) = Self::deserialize_map_key(raw)?;
89        let (data, ex_units) = Self::deserialize_map_value(raw)?;
90
91        Ok(Self {
92            tag,
93            index,
94            data,
95            ex_units,
96        })
97    }
98
99    fn deserialize_map_key<R: BufRead + Seek>(
100        raw: &mut Deserializer<R>,
101    ) -> Result<(RedeemerTag, BigNum), DeserializeError> {
102        let len = raw.array()?;
103        let mut read_len = CBORReadLen::new(len);
104        read_len.read_elems(2)?;
105
106        let tag = RedeemerTag::deserialize(raw)?;
107        let index = BigNum::deserialize(raw)?;
108
109        check_len_indefinite(raw, len)?;
110
111        Ok((tag, index))
112    }
113
114    fn deserialize_map_value<R: BufRead + Seek>(
115        raw: &mut Deserializer<R>,
116    ) -> Result<(PlutusData, ExUnits), DeserializeError> {
117        let len = raw.array()?;
118        let mut read_len = CBORReadLen::new(len);
119        read_len.read_elems(2)?;
120
121        let data = PlutusData::deserialize(raw)?;
122        let ex_units = ExUnits::deserialize(raw)?;
123
124        check_len_indefinite(raw, len)?;
125
126        Ok((data, ex_units))
127    }
128}
cardano_serialization_lib/serialization/plutus/redeemer.rs

cardano_serialization_lib/serialization/plutus/
redeemer.rs
