mithril_stm/protocol/single_signature/
signature_registered_party.rs

1use serde::{Deserialize, Serialize, Serializer, ser::SerializeTuple};
2
3use crate::{MembershipDigest, RegisteredParty, StmResult, membership_commitment::MerkleTreeLeaf};
4
5use super::{SignatureError, SingleSignature};
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.as_bytes_for_merkle_tree());
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: MembershipDigest>(
30        bytes: &[u8],
31    ) -> StmResult<SingleSignatureWithRegisteredParty> {
32        let reg_party = RegisteredParty::from_bytes(
33            bytes.get(0..104).ok_or(SignatureError::SerializationError)?,
34        )?;
35        let sig = SingleSignature::from_bytes::<D>(
36            bytes.get(104..).ok_or(SignatureError::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}
54
55#[cfg(test)]
56mod tests {
57    mod golden {
58        use rand_chacha::ChaCha20Rng;
59        use rand_core::SeedableRng;
60
61        use crate::{
62            ClosedKeyRegistration, KeyRegistration, MithrilMembershipDigest, Parameters, Signer,
63            SingleSignatureWithRegisteredParty,
64            signature_scheme::{BlsSigningKey, BlsVerificationKeyProofOfPossession},
65        };
66
67        const GOLDEN_JSON: &str = r#"
68        [
69            {
70                "sigma": [
71                149, 157, 201, 187, 140, 54, 0, 128, 209, 88, 16, 203, 61, 78, 77, 98,
72                161, 133, 58, 152, 29, 74, 217, 113, 64, 100, 10, 161, 186, 167, 133, 114,
73                211, 153, 218, 56, 223, 84, 105, 242, 41, 54, 224, 170, 208, 185, 126, 83
74                ],
75                "indexes": [1, 4, 5, 8],
76                "signer_index": 1
77            },
78            [
79                [
80                143, 161, 255, 48, 78, 57, 204, 220, 25, 221, 164, 252, 248, 14, 56, 126,
81                186, 135, 228, 188, 145, 181, 52, 200, 97, 99, 213, 46, 0, 199, 193, 89,
82                187, 88, 29, 135, 173, 244, 86, 36, 83, 54, 67, 164, 6, 137, 94, 72, 6,
83                105, 128, 128, 93, 48, 176, 11, 4, 246, 138, 48, 180, 133, 90, 142, 192,
84                24, 193, 111, 142, 31, 76, 111, 110, 234, 153, 90, 208, 192, 31, 124, 95,
85                102, 49, 158, 99, 52, 220, 165, 94, 251, 68, 69, 121, 16, 224, 194
86                ],
87                1
88            ]
89        ]
90        "#;
91
92        fn golden_value() -> SingleSignatureWithRegisteredParty {
93            let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
94            let msg = [0u8; 16];
95            let params = Parameters {
96                m: 10,
97                k: 5,
98                phi_f: 0.8,
99            };
100            let sk_1 = BlsSigningKey::generate(&mut rng);
101            let sk_2 = BlsSigningKey::generate(&mut rng);
102            let pk_1 = BlsVerificationKeyProofOfPossession::from(&sk_1);
103            let pk_2 = BlsVerificationKeyProofOfPossession::from(&sk_2);
104            let mut key_reg = KeyRegistration::init();
105            key_reg.register(1, pk_1).unwrap();
106            key_reg.register(1, pk_2).unwrap();
107            let closed_key_reg: ClosedKeyRegistration<MithrilMembershipDigest> = key_reg.close();
108            let signer = Signer::set_signer(1, 1, params, sk_1, pk_1.vk, closed_key_reg.clone());
109            let signature = signer.sign(&msg).unwrap();
110            SingleSignatureWithRegisteredParty {
111                sig: signature,
112                reg_party: closed_key_reg.reg_parties[0],
113            }
114        }
115
116        #[test]
117        fn golden_conversions() {
118            let value = serde_json::from_str(GOLDEN_JSON)
119                .expect("This JSON deserialization should not fail");
120            assert_eq!(golden_value(), value);
121
122            let serialized =
123                serde_json::to_string(&value).expect("This JSON serialization should not fail");
124            let golden_serialized = serde_json::to_string(&golden_value())
125                .expect("This JSON serialization should not fail");
126            assert_eq!(golden_serialized, serialized);
127        }
128    }
129}
mithril_stm/protocol/single_signature/signature_registered_party.rs

mithril_stm/protocol/single_signature/
signature_registered_party.rs
