cardano-serialization-lib 15.0.3

(De)serialization functions for the Cardano blockchain along with related utility functions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::*;

impl cbor_event::se::Serialize for Voter {
    fn serialize<'se, W: Write>(
        &self,
        serializer: &'se mut Serializer<W>,
    ) -> cbor_event::Result<&'se mut Serializer<W>> {
        self.0.serialize(serializer)
    }
}

impl Deserialize for Voter {
    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
        (|| -> Result<_, DeserializeError> {
            let voter_enum = VoterEnum::deserialize(raw)?;
            Ok(Self(voter_enum))
        })()
        .map_err(|e| e.annotate("Voter"))
    }
}

impl cbor_event::se::Serialize for VoterEnum {
    fn serialize<'se, W: Write>(
        &self,
        serializer: &'se mut Serializer<W>,
    ) -> cbor_event::Result<&'se mut Serializer<W>> {
        serializer.write_array(cbor_event::Len::Len(2))?;
        match &self {
            VoterEnum::ConstitutionalCommitteeHotCred(cred) => match &cred.0 {
                CredType::Key(key_hash) => {
                    serializer.write_unsigned_integer(0u64)?;
                    key_hash.serialize(serializer)?;
                }
                CredType::Script(script_hash) => {
                    serializer.write_unsigned_integer(1u64)?;
                    script_hash.serialize(serializer)?;
                }
            },
            VoterEnum::DRep(cred) => match &cred.0 {
                CredType::Key(key_hash) => {
                    serializer.write_unsigned_integer(2u64)?;
                    key_hash.serialize(serializer)?;
                }
                CredType::Script(script_hash) => {
                    serializer.write_unsigned_integer(3u64)?;
                    script_hash.serialize(serializer)?;
                }
            },
            VoterEnum::StakingPool(scripthash) => {
                serializer.write_unsigned_integer(4u64)?;
                scripthash.serialize(serializer)?;
            }
        };
        Ok(serializer)
    }
}

impl Deserialize for VoterEnum {
    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
        (|| -> Result<_, DeserializeError> {
            let len = raw.array()?;
            if let cbor_event::Len::Len(n) = len {
                if n != 2 {
                    return Err(DeserializeFailure::CBOR(cbor_event::Error::WrongLen(
                        2,
                        len,
                        "[id, hash]",
                    ))
                    .into());
                }
            }
            let voter = match raw.unsigned_integer()? {
                0 => VoterEnum::ConstitutionalCommitteeHotCred(Credential(CredType::Key(
                    Ed25519KeyHash::deserialize(raw)?,
                ))),
                1 => VoterEnum::ConstitutionalCommitteeHotCred(Credential(CredType::Script(
                    ScriptHash::deserialize(raw)?,
                ))),
                2 => VoterEnum::DRep(Credential(CredType::Key(Ed25519KeyHash::deserialize(
                    raw,
                )?))),
                3 => VoterEnum::DRep(Credential(CredType::Script(ScriptHash::deserialize(
                    raw,
                )?))),
                4 => VoterEnum::StakingPool(Ed25519KeyHash::deserialize(raw)?),
                n => {
                    return Err(DeserializeFailure::FixedValuesMismatch {
                        found: Key::Uint(n),
                        expected: vec![
                            Key::Uint(0),
                            Key::Uint(1),
                            Key::Uint(2),
                            Key::Uint(3),
                            Key::Uint(4),
                        ],
                    }
                    .into())
                }
            };
            if let cbor_event::Len::Indefinite = len {
                if raw.special()? != CBORSpecial::Break {
                    return Err(DeserializeFailure::EndingBreakMissing.into());
                }
            }
            Ok(voter)
        })()
        .map_err(|e| e.annotate("VoterEnum"))
    }
}