cardano_serialization_lib/serialization/certificates/
certificate.rs

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
use crate::serialization::map_names::CertificateIndexNames;
use crate::*;
use num_traits::FromPrimitive;
use std::io::{Seek, SeekFrom};

impl cbor_event::se::Serialize for CertificateEnum {
    fn serialize<'se, W: Write>(
        &self,
        serializer: &'se mut Serializer<W>,
    ) -> cbor_event::Result<&'se mut Serializer<W>> {
        match self {
            CertificateEnum::StakeRegistration(x) => x.serialize(serializer),
            CertificateEnum::StakeDeregistration(x) => x.serialize(serializer),
            CertificateEnum::StakeDelegation(x) => x.serialize(serializer),
            CertificateEnum::PoolRegistration(x) => x.serialize(serializer),
            CertificateEnum::PoolRetirement(x) => x.serialize(serializer),
            CertificateEnum::GenesisKeyDelegation(x) => x.serialize(serializer),
            CertificateEnum::MoveInstantaneousRewardsCert(x) => x.serialize(serializer),
            CertificateEnum::CommitteeHotAuth(x) => x.serialize(serializer),
            CertificateEnum::CommitteeColdResign(x) => x.serialize(serializer),
            CertificateEnum::DRepRegistration(x) => x.serialize(serializer),
            CertificateEnum::DRepDeregistration(x) => x.serialize(serializer),
            CertificateEnum::DRepUpdate(x) => x.serialize(serializer),
            CertificateEnum::StakeAndVoteDelegation(x) => x.serialize(serializer),
            CertificateEnum::StakeRegistrationAndDelegation(x) => x.serialize(serializer),
            CertificateEnum::StakeVoteRegistrationAndDelegation(x) => x.serialize(serializer),
            CertificateEnum::VoteDelegation(x) => x.serialize(serializer),
            CertificateEnum::VoteRegistrationAndDelegation(x) => x.serialize(serializer),
        }
    }
}

impl Deserialize for CertificateEnum {
    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
        (|| -> Result<_, DeserializeError> {
            let len = raw.array()?;
            let ret = Self::deserialize_as_embedded_group(raw, len);
            match len {
                cbor_event::Len::Len(_) =>
                /* TODO: check finite len somewhere */
                {
                    ()
                }
                cbor_event::Len::Indefinite => match raw.special()? {
                    CBORSpecial::Break =>
                    /* it's ok */
                    {
                        ()
                    }
                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
                },
            }
            ret
        })()
        .map_err(|e| e.annotate("CertificateEnum"))
    }
}

impl DeserializeEmbeddedGroup for CertificateEnum {
    fn deserialize_as_embedded_group<R: BufRead + Seek>(
        raw: &mut Deserializer<R>,
        len: cbor_event::Len,
    ) -> Result<Self, DeserializeError> {
        let cert_index = get_cert_index(raw)?;
        let index_enum =
            CertificateIndexNames::from_u64(cert_index).ok_or(DeserializeError::new(
                "CertificateEnum",
                DeserializeFailure::UnknownKey(Key::Uint(cert_index)),
            ))?;

        match index_enum {
            CertificateIndexNames::StakeRegistrationLegacy => {
                Ok(CertificateEnum::StakeRegistration(
                    StakeRegistration::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::StakeRegistrationConway => {
                Ok(CertificateEnum::StakeRegistration(
                    StakeRegistration::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::StakeDeregistrationLegacy => {
                Ok(CertificateEnum::StakeDeregistration(
                    StakeDeregistration::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::StakeDeregistrationConway => {
                Ok(CertificateEnum::StakeDeregistration(
                    StakeDeregistration::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::StakeDelegation => Ok(CertificateEnum::StakeDelegation(
                StakeDelegation::deserialize_as_embedded_group(raw, len)?,
            )),

            CertificateIndexNames::PoolRegistration => Ok(CertificateEnum::PoolRegistration(
                PoolRegistration::deserialize_as_embedded_group(raw, len)?,
            )),
            CertificateIndexNames::PoolRetirement => Ok(CertificateEnum::PoolRetirement(
                PoolRetirement::deserialize_as_embedded_group(raw, len)?,
            )),
            CertificateIndexNames::GenesisKeyDelegation => {
                Ok(CertificateEnum::GenesisKeyDelegation(
                    GenesisKeyDelegation::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::MoveInstantaneousRewardsCert => {
                Ok(CertificateEnum::MoveInstantaneousRewardsCert(
                    MoveInstantaneousRewardsCert::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::CommitteeHotAuth => {
                Ok(CertificateEnum::CommitteeHotAuth(
                    CommitteeHotAuth::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::CommitteeColdResign => {
                Ok(CertificateEnum::CommitteeColdResign(
                    CommitteeColdResign::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::DRepRegistration => Ok(CertificateEnum::DRepRegistration(
                DRepRegistration::deserialize_as_embedded_group(raw, len)?,
            )),
            CertificateIndexNames::DRepDeregistration => Ok(CertificateEnum::DRepDeregistration(
                DRepDeregistration::deserialize_as_embedded_group(raw, len)?,
            )),
            CertificateIndexNames::DRepUpdate => Ok(CertificateEnum::DRepUpdate(
                DRepUpdate::deserialize_as_embedded_group(raw, len)?,
            )),
            CertificateIndexNames::StakeAndVoteDelegation => {
                Ok(CertificateEnum::StakeAndVoteDelegation(
                    StakeAndVoteDelegation::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::StakeRegistrationAndDelegation => {
                Ok(CertificateEnum::StakeRegistrationAndDelegation(
                    StakeRegistrationAndDelegation::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::StakeVoteRegistrationAndDelegation => {
                Ok(CertificateEnum::StakeVoteRegistrationAndDelegation(
                    StakeVoteRegistrationAndDelegation::deserialize_as_embedded_group(raw, len)?,
                ))
            }
            CertificateIndexNames::VoteDelegation => Ok(CertificateEnum::VoteDelegation(
                VoteDelegation::deserialize_as_embedded_group(raw, len)?,
            )),
            CertificateIndexNames::VoteRegistrationAndDelegation => {
                Ok(CertificateEnum::VoteRegistrationAndDelegation(
                    VoteRegistrationAndDelegation::deserialize_as_embedded_group(raw, len)?,
                ))
            }
        }
    }
}

impl cbor_event::se::Serialize for Certificate {
    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 Certificate {
    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
        Ok(Self(CertificateEnum::deserialize(raw)?))
    }
}

fn get_cert_index<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<u64, DeserializeError> {
    let initial_position = raw
        .as_mut_ref()
        .seek(SeekFrom::Current(0))
        .map_err(|err| DeserializeFailure::IoError(err.to_string()))?;
    let index = raw.unsigned_integer()?;
    raw.as_mut_ref()
        .seek(SeekFrom::Start(initial_position))
        .map_err(|err| DeserializeFailure::IoError(err.to_string()))?;
    Ok(index)
}