mithril_stm/single_signature/
signature_registered_party.rs

1use blake2::digest::{Digest, FixedOutput};
2use serde::{ser::SerializeTuple, Deserialize, Serialize, Serializer};
3
4use crate::key_registration::RegisteredParty;
5use crate::{SingleSignature, StmSignatureError};
6
7/// Signature with its registered party.
8#[derive(Debug, Clone, Hash, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
9pub struct SingleSignatureWithRegisteredParty {
10    /// Stm signature
11    pub sig: SingleSignature,
12    /// Registered party
13    pub reg_party: RegisteredParty,
14}
15
16impl SingleSignatureWithRegisteredParty {
17    /// Convert `SingleSignatureWithRegisteredParty` to bytes
18    /// # Layout
19    /// * RegParty
20    /// * Signature
21    pub fn to_bytes(&self) -> Vec<u8> {
22        let mut out = Vec::new();
23        out.extend_from_slice(&self.reg_party.to_bytes());
24        out.extend_from_slice(&self.sig.to_bytes());
25
26        out
27    }
28    ///Extract a `SingleSignatureWithRegisteredParty` from a byte slice.
29    pub fn from_bytes<D: Digest + Clone + FixedOutput>(
30        bytes: &[u8],
31    ) -> Result<SingleSignatureWithRegisteredParty, StmSignatureError> {
32        let reg_party = RegisteredParty::from_bytes(
33            bytes
34                .get(0..104)
35                .ok_or(StmSignatureError::SerializationError)?,
36        )?;
37        let sig = SingleSignature::from_bytes::<D>(
38            bytes
39                .get(104..)
40                .ok_or(StmSignatureError::SerializationError)?,
41        )?;
42
43        Ok(SingleSignatureWithRegisteredParty { sig, reg_party })
44    }
45}
46
47impl Serialize for SingleSignatureWithRegisteredParty {
48    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
49    where
50        S: Serializer,
51    {
52        let mut tuple = serializer.serialize_tuple(2)?;
53        tuple.serialize_element(&self.sig)?;
54        tuple.serialize_element(&self.reg_party)?;
55        tuple.end()
56    }
57}