linera_chain/certificate/
timeout.rs1use linera_base::{
6 crypto::{ValidatorPublicKey, ValidatorSignature},
7 data_types::Round,
8};
9use serde::{
10 ser::{Serialize, SerializeStruct, Serializer},
11 Deserialize, Deserializer,
12};
13
14use super::{generic::GenericCertificate, Certificate};
15use crate::block::{ConversionError, Timeout};
16
17impl TryFrom<Certificate> for GenericCertificate<Timeout> {
18 type Error = ConversionError;
19
20 fn try_from(cert: Certificate) -> Result<Self, Self::Error> {
21 match cert {
22 Certificate::Timeout(timeout) => Ok(timeout),
23 _ => Err(ConversionError::Timeout),
24 }
25 }
26}
27
28impl From<GenericCertificate<Timeout>> for Certificate {
29 fn from(cert: GenericCertificate<Timeout>) -> Certificate {
30 Certificate::Timeout(cert)
31 }
32}
33
34impl Serialize for GenericCertificate<Timeout> {
35 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
36 let mut state = serializer.serialize_struct("TimeoutCertificate", 4)?;
37 state.serialize_field("value", self.inner())?;
38 state.serialize_field("round", &self.round)?;
39 state.serialize_field("signatures", self.signatures())?;
40 state.end()
41 }
42}
43
44impl<'de> Deserialize<'de> for GenericCertificate<Timeout> {
45 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
46 where
47 D: Deserializer<'de>,
48 {
49 #[derive(Deserialize)]
50 #[serde(rename = "TimeoutCertificate")]
51 struct Inner {
52 value: Timeout,
53 round: Round,
54 signatures: Vec<(ValidatorPublicKey, ValidatorSignature)>,
55 }
56 let inner = Inner::deserialize(deserializer)?;
57 if !crate::data_types::is_strictly_ordered(&inner.signatures) {
58 Err(serde::de::Error::custom("Vector is not strictly sorted"))
59 } else {
60 Ok(Self::new(inner.value, inner.round, inner.signatures))
61 }
62 }
63}