mithril_stm/single_signature/
signature_registered_party.rs

1use blake2::digest::{Digest, FixedOutput};
2use serde::{Deserialize, Serialize, Serializer, ser::SerializeTuple};
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.get(0..104).ok_or(StmSignatureError::SerializationError)?,
34        )?;
35        let sig = SingleSignature::from_bytes::<D>(
36            bytes.get(104..).ok_or(StmSignatureError::SerializationError)?,
37        )?;
38
39        Ok(SingleSignatureWithRegisteredParty { sig, reg_party })
40    }
41}
42
43impl Serialize for SingleSignatureWithRegisteredParty {
44    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
45    where
46        S: Serializer,
47    {
48        let mut tuple = serializer.serialize_tuple(2)?;
49        tuple.serialize_element(&self.sig)?;
50        tuple.serialize_element(&self.reg_party)?;
51        tuple.end()
52    }
53}