cardano_serialization_lib/serialization/
script_ref.rs

1use crate::*;
2
3impl Deserialize for ScriptRefEnum {
4    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
5        (|| -> Result<_, DeserializeError> {
6            let len = raw.array()?;
7            if let cbor_event::Len::Len(n) = len {
8                if n != 2 {
9                    return Err(DeserializeFailure::CBOR(cbor_event::Error::WrongLen(
10                        2,
11                        len,
12                        "[id, native_or_putus_script]",
13                    ))
14                        .into());
15                }
16            }
17            let script_ref = match raw.unsigned_integer()? {
18                0 => ScriptRefEnum::NativeScript(NativeScript::deserialize(raw)?),
19                1 => ScriptRefEnum::PlutusScript(PlutusScript::deserialize(raw)?),
20                2 => ScriptRefEnum::PlutusScript(
21                    PlutusScript::deserialize(raw)?.clone_as_version(&Language::new_plutus_v2()),
22                ),
23                3 => ScriptRefEnum::PlutusScript(
24                    PlutusScript::deserialize(raw)?.clone_as_version(&Language::new_plutus_v3()),
25                ),
26                n => {
27                    return Err(DeserializeFailure::FixedValueMismatch {
28                        found: Key::Uint(n),
29                        expected: Key::Uint(0),
30                    }
31                        .into())
32                }
33            };
34            if let cbor_event::Len::Indefinite = len {
35                if raw.special()? != CBORSpecial::Break {
36                    return Err(DeserializeFailure::EndingBreakMissing.into());
37                }
38            }
39            Ok(script_ref)
40        })()
41            .map_err(|e| e.annotate("ScriptRefEnum"))
42    }
43}
44
45impl cbor_event::se::Serialize for ScriptRefEnum {
46    fn serialize<'a, W: Write + Sized>(
47        &self,
48        serializer: &'a mut Serializer<W>,
49    ) -> cbor_event::Result<&'a mut Serializer<W>> {
50        serializer.write_array(cbor_event::Len::Len(2))?;
51        match &self {
52            ScriptRefEnum::NativeScript(native_script) => {
53                serializer.write_unsigned_integer(0)?;
54                native_script.serialize(serializer)?;
55            }
56            ScriptRefEnum::PlutusScript(plutus_script) => {
57                serializer.write_unsigned_integer(plutus_script.script_namespace() as u64)?;
58                plutus_script.serialize(serializer)?;
59            }
60        }
61        Ok(serializer)
62    }
63}
64
65impl Deserialize for ScriptRef {
66    fn deserialize<R: BufRead>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
67        (|| -> Result<_, DeserializeError> {
68            match raw.tag()? {
69                //bytes string tag
70                24 => Ok(ScriptRef(from_bytes(&raw.bytes()?)?)),
71                tag => {
72                    return Err(DeserializeFailure::TagMismatch {
73                        found: tag,
74                        expected: 24,
75                    }
76                        .into());
77                }
78            }
79        })()
80            .map_err(|e| e.annotate("ScriptRef"))
81    }
82}
83
84impl cbor_event::se::Serialize for ScriptRef {
85    fn serialize<'a, W: Write + Sized>(
86        &self,
87        serializer: &'a mut Serializer<W>,
88    ) -> cbor_event::Result<&'a mut Serializer<W>> {
89        let bytes = to_bytes(&self.0);
90        serializer.write_tag(24)?.write_bytes(&bytes)?;
91        Ok(serializer)
92    }
93}