cardano_serialization_lib/serialization/block/
header_body.rs

1use crate::*;
2
3impl cbor_event::se::Serialize for HeaderBody {
4    fn serialize<'se, W: Write>(
5        &self,
6        serializer: &'se mut Serializer<W>,
7    ) -> cbor_event::Result<&'se mut Serializer<W>> {
8        serializer.write_array(cbor_event::Len::Len(15))?;
9        self.block_number.serialize(serializer)?;
10        self.slot.serialize(serializer)?;
11        match &self.prev_hash {
12            Some(x) => x.serialize(serializer),
13            None => serializer.write_special(CBORSpecial::Null),
14        }?;
15        self.issuer_vkey.serialize(serializer)?;
16        self.vrf_vkey.serialize(serializer)?;
17        match &self.leader_cert {
18            HeaderLeaderCertEnum::NonceAndLeader(nonce_vrf, leader_vrf) => {
19                nonce_vrf.serialize(serializer)?;
20                leader_vrf.serialize(serializer)?;
21            }
22            HeaderLeaderCertEnum::VrfResult(vrf_cert) => {
23                vrf_cert.serialize(serializer)?;
24            }
25        }
26        self.block_body_size.serialize(serializer)?;
27        self.block_body_hash.serialize(serializer)?;
28        self.operational_cert
29            .serialize_as_embedded_group(serializer)?;
30        self.protocol_version
31            .serialize_as_embedded_group(serializer)?;
32        Ok(serializer)
33    }
34}
35
36impl Deserialize for HeaderBody {
37    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
38        (|| -> Result<_, DeserializeError> {
39            let len = raw.array()?;
40            let ret = Self::deserialize_as_embedded_group(raw, len);
41            match len {
42                cbor_event::Len::Len(_) =>
43                /* TODO: check finite len somewhere */
44                    {
45                        ()
46                    }
47                cbor_event::Len::Indefinite => match raw.special()? {
48                    CBORSpecial::Break =>
49                    /* it's ok */
50                        {
51                            ()
52                        }
53                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
54                },
55            }
56            ret
57        })()
58            .map_err(|e| e.annotate("HeaderBody"))
59    }
60}
61
62impl DeserializeEmbeddedGroup for HeaderBody {
63    fn deserialize_as_embedded_group<R: BufRead + Seek>(
64        raw: &mut Deserializer<R>,
65        len: cbor_event::Len,
66    ) -> Result<Self, DeserializeError> {
67        let block_number = (|| -> Result<_, DeserializeError> { Ok(u32::deserialize(raw)?) })()
68            .map_err(|e| e.annotate("block_number"))?;
69        let slot = (|| -> Result<_, DeserializeError> { Ok(SlotBigNum::deserialize(raw)?) })()
70            .map_err(|e| e.annotate("slot"))?;
71        let prev_hash = (|| -> Result<_, DeserializeError> {
72            Ok(match raw.cbor_type()? != CBORType::Special {
73                true => Some(BlockHash::deserialize(raw)?),
74                false => {
75                    if raw.special()? != CBORSpecial::Null {
76                        return Err(DeserializeFailure::ExpectedNull.into());
77                    }
78                    None
79                }
80            })
81        })()
82            .map_err(|e| e.annotate("prev_hash"))?;
83        let issuer_vkey = (|| -> Result<_, DeserializeError> { Ok(Vkey::deserialize(raw)?) })()
84            .map_err(|e| e.annotate("issuer_vkey"))?;
85        let vrf_vkey = (|| -> Result<_, DeserializeError> { Ok(VRFVKey::deserialize(raw)?) })()
86            .map_err(|e| e.annotate("vrf_vkey"))?;
87        let leader_cert = {
88            // NONCE VFR CERT, first of two certs
89            // or a single VRF RESULT CERT
90            // depending on the protocol version
91            let first_vrf_cert =
92                (|| -> Result<_, DeserializeError> { Ok(VRFCert::deserialize(raw)?) })()
93                    .map_err(|e| e.annotate("nonce_vrf"))?;
94            let cbor_type: cbor_event::Type = raw.cbor_type()?;
95            match cbor_type {
96                cbor_event::Type::Array => {
97                    // Legacy format, reading the second VRF cert
98                    let leader_vrf =
99                        (|| -> Result<_, DeserializeError> { Ok(VRFCert::deserialize(raw)?) })()
100                            .map_err(|e| e.annotate("leader_vrf"))?;
101                    HeaderLeaderCertEnum::NonceAndLeader(first_vrf_cert, leader_vrf)
102                }
103                cbor_event::Type::UnsignedInteger => {
104                    // New format, no second VRF cert is present
105                    HeaderLeaderCertEnum::VrfResult(first_vrf_cert)
106                }
107                t => {
108                    return Err(DeserializeError::new(
109                        "HeaderBody.leader_cert",
110                        DeserializeFailure::UnexpectedKeyType(t),
111                    ))
112                }
113            }
114        };
115        let block_body_size = (|| -> Result<_, DeserializeError> { Ok(u32::deserialize(raw)?) })()
116            .map_err(|e| e.annotate("block_body_size"))?;
117        let block_body_hash =
118            (|| -> Result<_, DeserializeError> { Ok(BlockHash::deserialize(raw)?) })()
119                .map_err(|e| e.annotate("block_body_hash"))?;
120
121        let operational_cert = (|| -> Result<_, DeserializeError> {
122            if raw.cbor_type()? == CBORType::Array {
123                Ok(OperationalCert::deserialize(raw)?)
124            } else {
125                Ok(OperationalCert::deserialize_as_embedded_group(raw, len)?)
126            }
127        })()
128            .map_err(|e| e.annotate("operational_cert"))?;
129        let protocol_version = (|| -> Result<_, DeserializeError> {
130            if raw.cbor_type()? == CBORType::Array {
131                Ok(ProtocolVersion::deserialize(raw)?)
132            } else {
133                Ok(ProtocolVersion::deserialize_as_embedded_group(raw, len)?)
134            }
135        })()
136            .map_err(|e| e.annotate("protocol_version"))?;
137        Ok(HeaderBody {
138            block_number,
139            slot,
140            prev_hash,
141            issuer_vkey,
142            vrf_vkey,
143            leader_cert,
144            block_body_size,
145            block_body_hash,
146            operational_cert,
147            protocol_version,
148        })
149    }
150}
cardano_serialization_lib/serialization/block/header_body.rs

cardano_serialization_lib/serialization/block/
header_body.rs
