cardano_serialization_lib/serialization/certificates/
certificate.rs

1use crate::serialization::map_names::CertificateIndexNames;
2use crate::*;
3use num_traits::FromPrimitive;
4use std::io::{Seek, SeekFrom};
5
6impl cbor_event::se::Serialize for CertificateEnum {
7    fn serialize<'se, W: Write>(
8        &self,
9        serializer: &'se mut Serializer<W>,
10    ) -> cbor_event::Result<&'se mut Serializer<W>> {
11        match self {
12            CertificateEnum::StakeRegistration(x) => x.serialize(serializer),
13            CertificateEnum::StakeDeregistration(x) => x.serialize(serializer),
14            CertificateEnum::StakeDelegation(x) => x.serialize(serializer),
15            CertificateEnum::PoolRegistration(x) => x.serialize(serializer),
16            CertificateEnum::PoolRetirement(x) => x.serialize(serializer),
17            CertificateEnum::GenesisKeyDelegation(x) => x.serialize(serializer),
18            CertificateEnum::MoveInstantaneousRewardsCert(x) => x.serialize(serializer),
19            CertificateEnum::CommitteeHotAuth(x) => x.serialize(serializer),
20            CertificateEnum::CommitteeColdResign(x) => x.serialize(serializer),
21            CertificateEnum::DRepRegistration(x) => x.serialize(serializer),
22            CertificateEnum::DRepDeregistration(x) => x.serialize(serializer),
23            CertificateEnum::DRepUpdate(x) => x.serialize(serializer),
24            CertificateEnum::StakeAndVoteDelegation(x) => x.serialize(serializer),
25            CertificateEnum::StakeRegistrationAndDelegation(x) => x.serialize(serializer),
26            CertificateEnum::StakeVoteRegistrationAndDelegation(x) => x.serialize(serializer),
27            CertificateEnum::VoteDelegation(x) => x.serialize(serializer),
28            CertificateEnum::VoteRegistrationAndDelegation(x) => x.serialize(serializer),
29        }
30    }
31}
32
33impl Deserialize for CertificateEnum {
34    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
35        (|| -> Result<_, DeserializeError> {
36            let len = raw.array()?;
37            let ret = Self::deserialize_as_embedded_group(raw, len);
38            match len {
39                cbor_event::Len::Len(_) =>
40                /* TODO: check finite len somewhere */
41                {
42                    ()
43                }
44                cbor_event::Len::Indefinite => match raw.special()? {
45                    CBORSpecial::Break =>
46                    /* it's ok */
47                    {
48                        ()
49                    }
50                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
51                },
52            }
53            ret
54        })()
55        .map_err(|e| e.annotate("CertificateEnum"))
56    }
57}
58
59impl DeserializeEmbeddedGroup for CertificateEnum {
60    fn deserialize_as_embedded_group<R: BufRead + Seek>(
61        raw: &mut Deserializer<R>,
62        len: cbor_event::Len,
63    ) -> Result<Self, DeserializeError> {
64        let cert_index = get_cert_index(raw)?;
65        let index_enum =
66            CertificateIndexNames::from_u64(cert_index).ok_or(DeserializeError::new(
67                "CertificateEnum",
68                DeserializeFailure::UnknownKey(Key::Uint(cert_index)),
69            ))?;
70
71        match index_enum {
72            CertificateIndexNames::StakeRegistrationLegacy => {
73                Ok(CertificateEnum::StakeRegistration(
74                    StakeRegistration::deserialize_as_embedded_group(raw, len)?,
75                ))
76            }
77            CertificateIndexNames::StakeRegistrationConway => {
78                Ok(CertificateEnum::StakeRegistration(
79                    StakeRegistration::deserialize_as_embedded_group(raw, len)?,
80                ))
81            }
82            CertificateIndexNames::StakeDeregistrationLegacy => {
83                Ok(CertificateEnum::StakeDeregistration(
84                    StakeDeregistration::deserialize_as_embedded_group(raw, len)?,
85                ))
86            }
87            CertificateIndexNames::StakeDeregistrationConway => {
88                Ok(CertificateEnum::StakeDeregistration(
89                    StakeDeregistration::deserialize_as_embedded_group(raw, len)?,
90                ))
91            }
92            CertificateIndexNames::StakeDelegation => Ok(CertificateEnum::StakeDelegation(
93                StakeDelegation::deserialize_as_embedded_group(raw, len)?,
94            )),
95
96            CertificateIndexNames::PoolRegistration => Ok(CertificateEnum::PoolRegistration(
97                PoolRegistration::deserialize_as_embedded_group(raw, len)?,
98            )),
99            CertificateIndexNames::PoolRetirement => Ok(CertificateEnum::PoolRetirement(
100                PoolRetirement::deserialize_as_embedded_group(raw, len)?,
101            )),
102            CertificateIndexNames::GenesisKeyDelegation => {
103                Ok(CertificateEnum::GenesisKeyDelegation(
104                    GenesisKeyDelegation::deserialize_as_embedded_group(raw, len)?,
105                ))
106            }
107            CertificateIndexNames::MoveInstantaneousRewardsCert => {
108                Ok(CertificateEnum::MoveInstantaneousRewardsCert(
109                    MoveInstantaneousRewardsCert::deserialize_as_embedded_group(raw, len)?,
110                ))
111            }
112            CertificateIndexNames::CommitteeHotAuth => {
113                Ok(CertificateEnum::CommitteeHotAuth(
114                    CommitteeHotAuth::deserialize_as_embedded_group(raw, len)?,
115                ))
116            }
117            CertificateIndexNames::CommitteeColdResign => {
118                Ok(CertificateEnum::CommitteeColdResign(
119                    CommitteeColdResign::deserialize_as_embedded_group(raw, len)?,
120                ))
121            }
122            CertificateIndexNames::DRepRegistration => Ok(CertificateEnum::DRepRegistration(
123                DRepRegistration::deserialize_as_embedded_group(raw, len)?,
124            )),
125            CertificateIndexNames::DRepDeregistration => Ok(CertificateEnum::DRepDeregistration(
126                DRepDeregistration::deserialize_as_embedded_group(raw, len)?,
127            )),
128            CertificateIndexNames::DRepUpdate => Ok(CertificateEnum::DRepUpdate(
129                DRepUpdate::deserialize_as_embedded_group(raw, len)?,
130            )),
131            CertificateIndexNames::StakeAndVoteDelegation => {
132                Ok(CertificateEnum::StakeAndVoteDelegation(
133                    StakeAndVoteDelegation::deserialize_as_embedded_group(raw, len)?,
134                ))
135            }
136            CertificateIndexNames::StakeRegistrationAndDelegation => {
137                Ok(CertificateEnum::StakeRegistrationAndDelegation(
138                    StakeRegistrationAndDelegation::deserialize_as_embedded_group(raw, len)?,
139                ))
140            }
141            CertificateIndexNames::StakeVoteRegistrationAndDelegation => {
142                Ok(CertificateEnum::StakeVoteRegistrationAndDelegation(
143                    StakeVoteRegistrationAndDelegation::deserialize_as_embedded_group(raw, len)?,
144                ))
145            }
146            CertificateIndexNames::VoteDelegation => Ok(CertificateEnum::VoteDelegation(
147                VoteDelegation::deserialize_as_embedded_group(raw, len)?,
148            )),
149            CertificateIndexNames::VoteRegistrationAndDelegation => {
150                Ok(CertificateEnum::VoteRegistrationAndDelegation(
151                    VoteRegistrationAndDelegation::deserialize_as_embedded_group(raw, len)?,
152                ))
153            }
154        }
155    }
156}
157
158impl cbor_event::se::Serialize for Certificate {
159    fn serialize<'se, W: Write>(
160        &self,
161        serializer: &'se mut Serializer<W>,
162    ) -> cbor_event::Result<&'se mut Serializer<W>> {
163        self.0.serialize(serializer)
164    }
165}
166
167impl Deserialize for Certificate {
168    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
169        Ok(Self(CertificateEnum::deserialize(raw)?))
170    }
171}
172
173fn get_cert_index<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<u64, DeserializeError> {
174    let initial_position = raw
175        .as_mut_ref()
176        .seek(SeekFrom::Current(0))
177        .map_err(|err| DeserializeFailure::IoError(err.to_string()))?;
178    let index = raw.unsigned_integer()?;
179    raw.as_mut_ref()
180        .seek(SeekFrom::Start(initial_position))
181        .map_err(|err| DeserializeFailure::IoError(err.to_string()))?;
182    Ok(index)
183}
cardano_serialization_lib/serialization/certificates/certificate.rs

cardano_serialization_lib/serialization/certificates/
certificate.rs
