cardano_serialization_lib/serialization/
native_script.rs

1use std::io::SeekFrom;
2use crate::*;
3
4impl cbor_event::se::Serialize for NativeScript {
5    fn serialize<'se, W: Write>(
6        &self,
7        serializer: &'se mut Serializer<W>,
8    ) -> cbor_event::Result<&'se mut Serializer<W>> {
9        self.0.serialize(serializer)
10    }
11}
12
13impl Deserialize for NativeScript {
14    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
15        Ok(Self(NativeScriptEnum::deserialize(raw)?))
16    }
17}
18
19impl cbor_event::se::Serialize for NativeScriptEnum {
20    fn serialize<'se, W: Write>(
21        &self,
22        serializer: &'se mut Serializer<W>,
23    ) -> cbor_event::Result<&'se mut Serializer<W>> {
24        match self {
25            NativeScriptEnum::ScriptPubkey(x) => x.serialize(serializer),
26            NativeScriptEnum::ScriptAll(x) => x.serialize(serializer),
27            NativeScriptEnum::ScriptAny(x) => x.serialize(serializer),
28            NativeScriptEnum::ScriptNOfK(x) => x.serialize(serializer),
29            NativeScriptEnum::TimelockStart(x) => x.serialize(serializer),
30            NativeScriptEnum::TimelockExpiry(x) => x.serialize(serializer),
31        }
32    }
33}
34
35impl Deserialize for NativeScriptEnum {
36    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
37        (|| -> Result<_, DeserializeError> {
38            let len = raw.array()?;
39            //let mut read_len = CBORReadLen::new(len);
40            let initial_position = raw.as_mut_ref().seek(SeekFrom::Current(0)).unwrap();
41            match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
42                Ok(ScriptPubkey::deserialize_as_embedded_group(
43                    raw, /*&mut read_len, */ len,
44                )?)
45            })(raw)
46            {
47                Ok(variant) => return Ok(NativeScriptEnum::ScriptPubkey(variant)),
48                Err(_) => raw
49                    .as_mut_ref()
50                    .seek(SeekFrom::Start(initial_position))
51                    .unwrap(),
52            };
53            match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
54                Ok(ScriptAll::deserialize_as_embedded_group(
55                    raw, /*mut read_len, */ len,
56                )?)
57            })(raw)
58            {
59                Ok(variant) => return Ok(NativeScriptEnum::ScriptAll(variant)),
60                Err(_) => raw
61                    .as_mut_ref()
62                    .seek(SeekFrom::Start(initial_position))
63                    .unwrap(),
64            };
65            match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
66                Ok(ScriptAny::deserialize_as_embedded_group(
67                    raw, /*mut read_len, */ len,
68                )?)
69            })(raw)
70            {
71                Ok(variant) => return Ok(NativeScriptEnum::ScriptAny(variant)),
72                Err(_) => raw
73                    .as_mut_ref()
74                    .seek(SeekFrom::Start(initial_position))
75                    .unwrap(),
76            };
77            match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
78                Ok(ScriptNOfK::deserialize_as_embedded_group(
79                    raw, /*mut read_len, */ len,
80                )?)
81            })(raw)
82            {
83                Ok(variant) => return Ok(NativeScriptEnum::ScriptNOfK(variant)),
84                Err(_) => raw
85                    .as_mut_ref()
86                    .seek(SeekFrom::Start(initial_position))
87                    .unwrap(),
88            };
89            match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
90                Ok(TimelockStart::deserialize_as_embedded_group(
91                    raw, /*mut read_len, */ len,
92                )?)
93            })(raw)
94            {
95                Ok(variant) => return Ok(NativeScriptEnum::TimelockStart(variant)),
96                Err(_) => raw
97                    .as_mut_ref()
98                    .seek(SeekFrom::Start(initial_position))
99                    .unwrap(),
100            };
101            match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
102                Ok(TimelockExpiry::deserialize_as_embedded_group(
103                    raw, /*mut read_len, */ len,
104                )?)
105            })(raw)
106            {
107                Ok(variant) => return Ok(NativeScriptEnum::TimelockExpiry(variant)),
108                Err(_) => raw
109                    .as_mut_ref()
110                    .seek(SeekFrom::Start(initial_position))
111                    .unwrap(),
112            };
113            match len {
114                cbor_event::Len::Len(_) => (), /*read_len.finish()?*/
115                cbor_event::Len::Indefinite => match raw.special()? {
116                    CBORSpecial::Break => (), /*read_len.finish()?*/
117                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
118                },
119            }
120            Err(DeserializeError::new(
121                "NativeScriptEnum",
122                DeserializeFailure::NoVariantMatched.into(),
123            ))
124        })()
125            .map_err(|e| e.annotate("NativeScriptEnum"))
126    }
127}
128
129
130impl cbor_event::se::Serialize for ScriptPubkey {
131    fn serialize<'se, W: Write>(
132        &self,
133        serializer: &'se mut Serializer<W>,
134    ) -> cbor_event::Result<&'se mut Serializer<W>> {
135        serializer.write_array(cbor_event::Len::Len(2))?;
136        self.serialize_as_embedded_group(serializer)
137    }
138}
139
140impl SerializeEmbeddedGroup for ScriptPubkey {
141    fn serialize_as_embedded_group<'se, W: Write>(
142        &self,
143        serializer: &'se mut Serializer<W>,
144    ) -> cbor_event::Result<&'se mut Serializer<W>> {
145        serializer.write_unsigned_integer(0u64)?;
146        self.addr_keyhash.serialize(serializer)?;
147        Ok(serializer)
148    }
149}
150
151impl Deserialize for ScriptPubkey {
152    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
153        (|| -> Result<_, DeserializeError> {
154            let len = raw.array()?;
155            let mut read_len = CBORReadLen::new(len);
156            read_len.read_elems(2)?;
157            let ret = Self::deserialize_as_embedded_group(raw, /*mut read_len, */ len);
158            match len {
159                cbor_event::Len::Len(_) => read_len.finish()?,
160                cbor_event::Len::Indefinite => match raw.special()? {
161                    CBORSpecial::Break => (),
162                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
163                },
164            }
165            ret
166        })()
167            .map_err(|e| e.annotate("ScriptPubkey"))
168    }
169}
170
171impl DeserializeEmbeddedGroup for ScriptPubkey {
172    fn deserialize_as_embedded_group<R: BufRead + Seek>(
173        raw: &mut Deserializer<R>,
174        /*read_len: &mut CBORReadLen, */ _: cbor_event::Len,
175    ) -> Result<Self, DeserializeError> {
176        (|| -> Result<_, DeserializeError> {
177            let index_0_value = raw.unsigned_integer()?;
178            if index_0_value != 0 {
179                return Err(DeserializeFailure::FixedValueMismatch {
180                    found: Key::Uint(index_0_value),
181                    expected: Key::Uint(0),
182                }
183                    .into());
184            }
185            Ok(())
186        })()
187            .map_err(|e| e.annotate("index_0"))?;
188        let addr_keyhash =
189            (|| -> Result<_, DeserializeError> { Ok(Ed25519KeyHash::deserialize(raw)?) })()
190                .map_err(|e| e.annotate("addr_keyhash"))?;
191        Ok(ScriptPubkey { addr_keyhash })
192    }
193}
194
195impl cbor_event::se::Serialize for ScriptAll {
196    fn serialize<'se, W: Write>(
197        &self,
198        serializer: &'se mut Serializer<W>,
199    ) -> cbor_event::Result<&'se mut Serializer<W>> {
200        serializer.write_array(cbor_event::Len::Len(2))?;
201        self.serialize_as_embedded_group(serializer)
202    }
203}
204
205impl SerializeEmbeddedGroup for ScriptAll {
206    fn serialize_as_embedded_group<'se, W: Write>(
207        &self,
208        serializer: &'se mut Serializer<W>,
209    ) -> cbor_event::Result<&'se mut Serializer<W>> {
210        serializer.write_unsigned_integer(1u64)?;
211        self.native_scripts.serialize(serializer)?;
212        Ok(serializer)
213    }
214}
215
216impl Deserialize for ScriptAll {
217    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
218        (|| -> Result<_, DeserializeError> {
219            let len = raw.array()?;
220            let mut read_len = CBORReadLen::new(len);
221            read_len.read_elems(2)?;
222            let ret = Self::deserialize_as_embedded_group(raw, /*mut read_len, */ len);
223            match len {
224                cbor_event::Len::Len(_) => read_len.finish()?,
225                cbor_event::Len::Indefinite => match raw.special()? {
226                    CBORSpecial::Break => (),
227                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
228                },
229            }
230            ret
231        })()
232            .map_err(|e| e.annotate("ScriptAll"))
233    }
234}
235
236impl DeserializeEmbeddedGroup for ScriptAll {
237    fn deserialize_as_embedded_group<R: BufRead + Seek>(
238        raw: &mut Deserializer<R>,
239        /*read_len: &mut CBORReadLen, */ _: cbor_event::Len,
240    ) -> Result<Self, DeserializeError> {
241        (|| -> Result<_, DeserializeError> {
242            let index_0_value = raw.unsigned_integer()?;
243            if index_0_value != 1 {
244                return Err(DeserializeFailure::FixedValueMismatch {
245                    found: Key::Uint(index_0_value),
246                    expected: Key::Uint(1),
247                }
248                    .into());
249            }
250            Ok(())
251        })()
252            .map_err(|e| e.annotate("index_0"))?;
253        let native_scripts =
254            (|| -> Result<_, DeserializeError> { Ok(NativeScripts::deserialize(raw)?) })()
255                .map_err(|e| e.annotate("native_scripts"))?;
256        Ok(ScriptAll { native_scripts })
257    }
258}
259
260impl cbor_event::se::Serialize for ScriptAny {
261    fn serialize<'se, W: Write>(
262        &self,
263        serializer: &'se mut Serializer<W>,
264    ) -> cbor_event::Result<&'se mut Serializer<W>> {
265        serializer.write_array(cbor_event::Len::Len(2))?;
266        self.serialize_as_embedded_group(serializer)
267    }
268}
269
270impl SerializeEmbeddedGroup for ScriptAny {
271    fn serialize_as_embedded_group<'se, W: Write>(
272        &self,
273        serializer: &'se mut Serializer<W>,
274    ) -> cbor_event::Result<&'se mut Serializer<W>> {
275        serializer.write_unsigned_integer(2u64)?;
276        self.native_scripts.serialize(serializer)?;
277        Ok(serializer)
278    }
279}
280
281impl Deserialize for ScriptAny {
282    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
283        (|| -> Result<_, DeserializeError> {
284            let len = raw.array()?;
285            let mut read_len = CBORReadLen::new(len);
286            read_len.read_elems(2)?;
287            let ret = Self::deserialize_as_embedded_group(raw, /*mut read_len, */ len);
288            match len {
289                cbor_event::Len::Len(_) => read_len.finish()?,
290                cbor_event::Len::Indefinite => match raw.special()? {
291                    CBORSpecial::Break => (),
292                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
293                },
294            }
295            ret
296        })()
297            .map_err(|e| e.annotate("ScriptAny"))
298    }
299}
300
301impl DeserializeEmbeddedGroup for ScriptAny {
302    fn deserialize_as_embedded_group<R: BufRead + Seek>(
303        raw: &mut Deserializer<R>,
304        /*/*read_len: &mut CBORReadLen, */*/ _: cbor_event::Len,
305    ) -> Result<Self, DeserializeError> {
306        (|| -> Result<_, DeserializeError> {
307            let index_0_value = raw.unsigned_integer()?;
308            if index_0_value != 2 {
309                return Err(DeserializeFailure::FixedValueMismatch {
310                    found: Key::Uint(index_0_value),
311                    expected: Key::Uint(2),
312                }
313                    .into());
314            }
315            Ok(())
316        })()
317            .map_err(|e| e.annotate("index_0"))?;
318        let native_scripts =
319            (|| -> Result<_, DeserializeError> { Ok(NativeScripts::deserialize(raw)?) })()
320                .map_err(|e| e.annotate("native_scripts"))?;
321        Ok(ScriptAny { native_scripts })
322    }
323}
324
325impl cbor_event::se::Serialize for ScriptNOfK {
326    fn serialize<'se, W: Write>(
327        &self,
328        serializer: &'se mut Serializer<W>,
329    ) -> cbor_event::Result<&'se mut Serializer<W>> {
330        serializer.write_array(cbor_event::Len::Len(3))?;
331        self.serialize_as_embedded_group(serializer)
332    }
333}
334
335impl SerializeEmbeddedGroup for ScriptNOfK {
336    fn serialize_as_embedded_group<'se, W: Write>(
337        &self,
338        serializer: &'se mut Serializer<W>,
339    ) -> cbor_event::Result<&'se mut Serializer<W>> {
340        serializer.write_unsigned_integer(3u64)?;
341        self.n.serialize(serializer)?;
342        self.native_scripts.serialize(serializer)?;
343        Ok(serializer)
344    }
345}
346
347impl Deserialize for ScriptNOfK {
348    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
349        (|| -> Result<_, DeserializeError> {
350            let len = raw.array()?;
351            let mut read_len = CBORReadLen::new(len);
352            read_len.read_elems(3)?;
353            let ret = Self::deserialize_as_embedded_group(raw, /*mut read_len, */ len);
354            match len {
355                cbor_event::Len::Len(_) => read_len.finish()?,
356                cbor_event::Len::Indefinite => match raw.special()? {
357                    CBORSpecial::Break => (),
358                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
359                },
360            }
361            ret
362        })()
363            .map_err(|e| e.annotate("ScriptNOfK"))
364    }
365}
366
367impl DeserializeEmbeddedGroup for ScriptNOfK {
368    fn deserialize_as_embedded_group<R: BufRead + Seek>(
369        raw: &mut Deserializer<R>,
370        /*read_len: &mut CBORReadLen, */ _: cbor_event::Len,
371    ) -> Result<Self, DeserializeError> {
372        (|| -> Result<_, DeserializeError> {
373            let index_0_value = raw.unsigned_integer()?;
374            if index_0_value != 3 {
375                return Err(DeserializeFailure::FixedValueMismatch {
376                    found: Key::Uint(index_0_value),
377                    expected: Key::Uint(3),
378                }
379                    .into());
380            }
381            Ok(())
382        })()
383            .map_err(|e| e.annotate("index_0"))?;
384        let n = (|| -> Result<_, DeserializeError> { Ok(u32::deserialize(raw)?) })()
385            .map_err(|e| e.annotate("n"))?;
386        let native_scripts =
387            (|| -> Result<_, DeserializeError> { Ok(NativeScripts::deserialize(raw)?) })()
388                .map_err(|e| e.annotate("native_scripts"))?;
389        Ok(ScriptNOfK { n, native_scripts })
390    }
391}
392
393impl cbor_event::se::Serialize for TimelockStart {
394    fn serialize<'se, W: Write>(
395        &self,
396        serializer: &'se mut Serializer<W>,
397    ) -> cbor_event::Result<&'se mut Serializer<W>> {
398        serializer.write_array(cbor_event::Len::Len(2))?;
399        self.serialize_as_embedded_group(serializer)
400    }
401}
402
403impl SerializeEmbeddedGroup for TimelockStart {
404    fn serialize_as_embedded_group<'se, W: Write>(
405        &self,
406        serializer: &'se mut Serializer<W>,
407    ) -> cbor_event::Result<&'se mut Serializer<W>> {
408        serializer.write_unsigned_integer(4u64)?;
409        self.slot.serialize(serializer)?;
410        Ok(serializer)
411    }
412}
413
414impl Deserialize for TimelockStart {
415    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
416        (|| -> Result<_, DeserializeError> {
417            let len = raw.array()?;
418            let mut read_len = CBORReadLen::new(len);
419            read_len.read_elems(2)?;
420            let ret = Self::deserialize_as_embedded_group(raw, /*mut read_len, */ len);
421            match len {
422                cbor_event::Len::Len(_) => read_len.finish()?,
423                cbor_event::Len::Indefinite => match raw.special()? {
424                    CBORSpecial::Break => (),
425                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
426                },
427            }
428            ret
429        })()
430            .map_err(|e| e.annotate("TimelockStart"))
431    }
432}
433
434impl DeserializeEmbeddedGroup for TimelockStart {
435    fn deserialize_as_embedded_group<R: BufRead + Seek>(
436        raw: &mut Deserializer<R>,
437        /*read_len: &mut CBORReadLen, */ _: cbor_event::Len,
438    ) -> Result<Self, DeserializeError> {
439        (|| -> Result<_, DeserializeError> {
440            let index_0_value = raw.unsigned_integer()?;
441            if index_0_value != 4 {
442                return Err(DeserializeFailure::FixedValueMismatch {
443                    found: Key::Uint(index_0_value),
444                    expected: Key::Uint(4),
445                }
446                    .into());
447            }
448            Ok(())
449        })()
450            .map_err(|e| e.annotate("index_0"))?;
451        let slot = (|| -> Result<_, DeserializeError> { Ok(SlotBigNum::deserialize(raw)?) })()
452            .map_err(|e| e.annotate("slot"))?;
453        Ok(TimelockStart { slot })
454    }
455}
456
457impl cbor_event::se::Serialize for TimelockExpiry {
458    fn serialize<'se, W: Write>(
459        &self,
460        serializer: &'se mut Serializer<W>,
461    ) -> cbor_event::Result<&'se mut Serializer<W>> {
462        serializer.write_array(cbor_event::Len::Len(2))?;
463        self.serialize_as_embedded_group(serializer)
464    }
465}
466
467impl SerializeEmbeddedGroup for TimelockExpiry {
468    fn serialize_as_embedded_group<'se, W: Write>(
469        &self,
470        serializer: &'se mut Serializer<W>,
471    ) -> cbor_event::Result<&'se mut Serializer<W>> {
472        serializer.write_unsigned_integer(5u64)?;
473        self.slot.serialize(serializer)?;
474        Ok(serializer)
475    }
476}
477
478impl Deserialize for TimelockExpiry {
479    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
480        (|| -> Result<_, DeserializeError> {
481            let len = raw.array()?;
482            let mut read_len = CBORReadLen::new(len);
483            read_len.read_elems(2)?;
484            let ret = Self::deserialize_as_embedded_group(raw, /*&mut read_len, */ len);
485            match len {
486                cbor_event::Len::Len(_) => read_len.finish()?,
487                cbor_event::Len::Indefinite => match raw.special()? {
488                    CBORSpecial::Break => (),
489                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
490                },
491            }
492            ret
493        })()
494            .map_err(|e| e.annotate("TimelockExpiry"))
495    }
496}
497
498impl DeserializeEmbeddedGroup for TimelockExpiry {
499    fn deserialize_as_embedded_group<R: BufRead + Seek>(
500        raw: &mut Deserializer<R>,
501        /*read_len: &mut CBORReadLen, */ _: cbor_event::Len,
502    ) -> Result<Self, DeserializeError> {
503        (|| -> Result<_, DeserializeError> {
504            let index_0_value = raw.unsigned_integer()?;
505            if index_0_value != 5 {
506                return Err(DeserializeFailure::FixedValueMismatch {
507                    found: Key::Uint(index_0_value),
508                    expected: Key::Uint(5),
509                }
510                    .into());
511            }
512            Ok(())
513        })()
514            .map_err(|e| e.annotate("index_0"))?;
515        let slot = (|| -> Result<_, DeserializeError> { Ok(SlotBigNum::deserialize(raw)?) })()
516            .map_err(|e| e.annotate("slot"))?;
517        Ok(TimelockExpiry { slot })
518    }
519}
cardano_serialization_lib/serialization/native_script.rs

cardano_serialization_lib/serialization/
native_script.rs
