cardano_serialization_lib/serialization/certificates/
pool_registration.rs

1use crate::serialization::map_names::CertificateIndexNames;
2use crate::serialization::utils::{check_len, deserialize_and_check_index, is_break_tag, serialize_and_check_index};
3use crate::*;
4use num_traits::ToPrimitive;
5
6impl cbor_event::se::Serialize for Relays {
7    fn serialize<'se, W: Write>(
8        &self,
9        serializer: &'se mut Serializer<W>,
10    ) -> cbor_event::Result<&'se mut Serializer<W>> {
11        serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
12        for element in &self.0 {
13            element.serialize(serializer)?;
14        }
15        Ok(serializer)
16    }
17}
18
19impl Deserialize for Relays {
20    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
21        let mut arr = Vec::new();
22        (|| -> Result<_, DeserializeError> {
23            let len = raw.array()?;
24            while match len {
25                cbor_event::Len::Len(n) => arr.len() < n as usize,
26                cbor_event::Len::Indefinite => true,
27            } {
28                if is_break_tag(raw, "Relays")? {
29                    break;
30                }
31                arr.push(Relay::deserialize(raw)?);
32            }
33            Ok(())
34        })()
35        .map_err(|e| e.annotate("Relays"))?;
36        Ok(Self(arr))
37    }
38}
39
40impl cbor_event::se::Serialize for PoolParams {
41    fn serialize<'se, W: Write>(
42        &self,
43        serializer: &'se mut Serializer<W>,
44    ) -> cbor_event::Result<&'se mut Serializer<W>> {
45        serializer.write_array(cbor_event::Len::Len(9))?;
46        self.serialize_as_embedded_group(serializer)
47    }
48}
49
50impl SerializeEmbeddedGroup for PoolParams {
51    fn serialize_as_embedded_group<'se, W: Write>(
52        &self,
53        serializer: &'se mut Serializer<W>,
54    ) -> cbor_event::Result<&'se mut Serializer<W>> {
55        self.operator.serialize(serializer)?;
56        self.vrf_keyhash.serialize(serializer)?;
57        self.pledge.serialize(serializer)?;
58        self.cost.serialize(serializer)?;
59        self.margin.serialize(serializer)?;
60        self.reward_account.serialize(serializer)?;
61        self.pool_owners.serialize(serializer)?;
62        self.relays.serialize(serializer)?;
63        match &self.pool_metadata {
64            Some(x) => x.serialize(serializer),
65            None => serializer.write_special(CBORSpecial::Null),
66        }?;
67        Ok(serializer)
68    }
69}
70
71impl_deserialize_for_wrapped_tuple!(PoolParams);
72
73impl DeserializeEmbeddedGroup for PoolParams {
74    fn deserialize_as_embedded_group<R: BufRead + Seek>(
75        raw: &mut Deserializer<R>,
76        _: cbor_event::Len,
77    ) -> Result<Self, DeserializeError> {
78        let operator =
79            (|| -> Result<_, DeserializeError> { Ok(Ed25519KeyHash::deserialize(raw)?) })()
80                .map_err(|e| e.annotate("operator"))?;
81        let vrf_keyhash =
82            (|| -> Result<_, DeserializeError> { Ok(VRFKeyHash::deserialize(raw)?) })()
83                .map_err(|e| e.annotate("vrf_keyhash"))?;
84        let pledge = (|| -> Result<_, DeserializeError> { Ok(Coin::deserialize(raw)?) })()
85            .map_err(|e| e.annotate("pledge"))?;
86        let cost = (|| -> Result<_, DeserializeError> { Ok(Coin::deserialize(raw)?) })()
87            .map_err(|e| e.annotate("cost"))?;
88        let margin = (|| -> Result<_, DeserializeError> { Ok(UnitInterval::deserialize(raw)?) })()
89            .map_err(|e| e.annotate("margin"))?;
90        let reward_account =
91            (|| -> Result<_, DeserializeError> { Ok(RewardAddress::deserialize(raw)?) })()
92                .map_err(|e| e.annotate("reward_account"))?;
93        let pool_owners =
94            (|| -> Result<_, DeserializeError> { Ok(Ed25519KeyHashes::deserialize(raw)?) })()
95                .map_err(|e| e.annotate("pool_owners"))?;
96        let relays = (|| -> Result<_, DeserializeError> { Ok(Relays::deserialize(raw)?) })()
97            .map_err(|e| e.annotate("relays"))?;
98        let pool_metadata = (|| -> Result<_, DeserializeError> {
99            Ok(match raw.cbor_type()? != CBORType::Special {
100                true => Some(PoolMetadata::deserialize(raw)?),
101                false => {
102                    if raw.special()? != CBORSpecial::Null {
103                        return Err(DeserializeFailure::ExpectedNull.into());
104                    }
105                    None
106                }
107            })
108        })()
109        .map_err(|e| e.annotate("pool_metadata"))?;
110        Ok(PoolParams {
111            operator,
112            vrf_keyhash,
113            pledge,
114            cost,
115            margin,
116            reward_account,
117            pool_owners,
118            relays,
119            pool_metadata,
120        })
121    }
122}
123
124impl cbor_event::se::Serialize for PoolRegistration {
125    fn serialize<'se, W: Write>(
126        &self,
127        serializer: &'se mut Serializer<W>,
128    ) -> cbor_event::Result<&'se mut Serializer<W>> {
129        serializer.write_array(cbor_event::Len::Len(10))?;
130        self.serialize_as_embedded_group(serializer)
131    }
132}
133
134impl SerializeEmbeddedGroup for PoolRegistration {
135    fn serialize_as_embedded_group<'se, W: Write>(
136        &self,
137        serializer: &'se mut Serializer<W>,
138    ) -> cbor_event::Result<&'se mut Serializer<W>> {
139        let proposal_index = CertificateIndexNames::PoolRegistration.to_u64();
140        serialize_and_check_index(serializer, proposal_index, "PoolRegistration")?;
141
142        self.pool_params.serialize_as_embedded_group(serializer)?;
143        Ok(serializer)
144    }
145}
146
147impl_deserialize_for_wrapped_tuple!(PoolRegistration);
148
149impl DeserializeEmbeddedGroup for PoolRegistration {
150    fn deserialize_as_embedded_group<R: BufRead + Seek>(
151        raw: &mut Deserializer<R>,
152        len: cbor_event::Len,
153    ) -> Result<Self, DeserializeError> {
154        check_len(len, 10, "(cert_index, pool_params (without array) )")?;
155
156        let cert_index = CertificateIndexNames::PoolRegistration.to_u64();
157        deserialize_and_check_index(raw, cert_index, "cert_index")?;
158
159        let pool_params = (|| -> Result<_, DeserializeError> {
160            Ok(PoolParams::deserialize_as_embedded_group(raw, len)?)
161        })()
162        .map_err(|e| e.annotate("pool_params"))?;
163        Ok(PoolRegistration { pool_params })
164    }
165}
cardano_serialization_lib/serialization/certificates/pool_registration.rs

cardano_serialization_lib/serialization/certificates/
pool_registration.rs
