signature registered party

Update mithril-stm/src/single_signature/mod.rs

Co-authored-by: Jean-Philippe Raynaud <jp.raynaud@gmail.com>

Author: curiecrypt

mithril-stm/src/lib.rs

@@ -16,10 +16,9 @@ pub use error::{
 };
 pub use key_reg::{ClosedKeyReg, KeyReg};
 pub use participant::{StmInitializer, StmSigner, StmVerificationKey, StmVerificationKeyPoP};
-pub use single_signature::StmSig;
+pub use single_signature::{StmSig, StmSigRegParty};
 pub use stm::{
     CoreVerifier, Index, Stake, StmAggrSig, StmAggrVerificationKey, StmClerk, StmParameters,
-    StmSigRegParty,
 };
 
 #[cfg(feature = "benchmark-internals")]

mithril-stm/src/participant/signer.rs

@@ -1,9 +1,10 @@
+use blake2::digest::{Digest, FixedOutput};
+
 use crate::bls_multi_signature::{Signature, SigningKey, VerificationKey};
 use crate::eligibility_check::ev_lt_phi;
 use crate::key_reg::ClosedKeyReg;
 use crate::single_signature::StmSig;
 use crate::stm::{Stake, StmParameters};
-use blake2::digest::{Digest, FixedOutput};
 
 /// Wrapper of the MultiSignature Verification key
 pub type StmVerificationKey = VerificationKey;

mithril-stm/src/single_signature/mod.rs

@@ -1,3 +1,5 @@
 mod signature;
+mod signature_registered_party;
 
-pub use crate::single_signature::signature::StmSig;
+pub use signature::*;
+pub use signature_registered_party::*;

mithril-stm/src/single_signature/signature.rs

@@ -1,12 +1,14 @@
+use std::cmp::Ordering;
+use std::hash::{Hash, Hasher};
+
+use blake2::digest::{Digest, FixedOutput};
+use serde::{Deserialize, Serialize};
+
 use crate::bls_multi_signature::Signature;
 use crate::eligibility_check::ev_lt_phi;
 use crate::{
     Index, Stake, StmAggrVerificationKey, StmParameters, StmSignatureError, StmVerificationKey,
 };
-use blake2::digest::{Digest, FixedOutput};
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::hash::{Hash, Hasher};
 
 /// Signature created by a single party who has won the lottery.
 #[derive(Debug, Clone, Serialize, Deserialize)]

mithril-stm/src/single_signature/signature_registered_party.rs

@@ -0,0 +1,50 @@
+use blake2::digest::{Digest, FixedOutput};
+use serde::ser::SerializeTuple;
+use serde::{Deserialize, Serialize, Serializer};
+
+use crate::key_reg::RegParty;
+use crate::{StmSig, StmSignatureError};
+
+/// Signature with its registered party.
+#[derive(Debug, Clone, Hash, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
+pub struct StmSigRegParty {
+    /// Stm signature
+    pub sig: StmSig,
+    /// Registered party
+    pub reg_party: RegParty,
+}
+
+impl StmSigRegParty {
+    /// Convert StmSigRegParty to bytes
+    /// # Layout
+    /// * RegParty
+    /// * Signature
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut out = Vec::new();
+        out.extend_from_slice(&self.reg_party.to_bytes());
+        out.extend_from_slice(&self.sig.to_bytes());
+
+        out
+    }
+    ///Extract a `StmSigRegParty` from a byte slice.
+    pub fn from_bytes<D: Digest + Clone + FixedOutput>(
+        bytes: &[u8],
+    ) -> Result<StmSigRegParty, StmSignatureError> {
+        let reg_party = RegParty::from_bytes(&bytes[0..104])?;
+        let sig = StmSig::from_bytes::<D>(&bytes[104..])?;
+
+        Ok(StmSigRegParty { sig, reg_party })
+    }
+}
+
+impl Serialize for StmSigRegParty {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut tuple = serializer.serialize_tuple(2)?;
+        tuple.serialize_element(&self.sig)?;
+        tuple.serialize_element(&self.reg_party)?;
+        tuple.end()
+    }
+}

mithril-stm/src/stm.rs

@@ -105,21 +105,20 @@
 //! # }
 //! ```
 
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::convert::{From, TryFrom, TryInto};
+
+use blake2::digest::{Digest, FixedOutput};
+use serde::{Deserialize, Serialize};
+
 use crate::bls_multi_signature::{Signature, VerificationKey};
 use crate::error::{
     AggregationError, CoreVerifierError, RegisterError, StmAggregateSignatureError,
-    StmSignatureError,
 };
 use crate::key_reg::{ClosedKeyReg, RegParty};
 use crate::merkle_tree::{BatchPath, MTLeaf, MerkleTreeCommitmentBatchCompat};
 use crate::participant::{StmSigner, StmVerificationKey};
-use crate::single_signature::StmSig;
-use blake2::digest::{Digest, FixedOutput};
-use serde::ser::SerializeTuple;
-use serde::{Deserialize, Serialize, Serializer};
-use std::collections::{BTreeMap, HashMap, HashSet};
-use std::convert::{From, TryFrom, TryInto};
-use std::hash::Hash;
+use crate::single_signature::{StmSig, StmSigRegParty};
 
 /// The quantity of stake held by a party, represented as a `u64`.
 pub type Stake = u64;
@@ -218,50 +217,6 @@ impl<D: Clone + Digest + FixedOutput> From<&ClosedKeyReg<D>> for StmAggrVerifica
     }
 }
 
-/// Signature with its registered party.
-#[derive(Debug, Clone, Hash, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
-pub struct StmSigRegParty {
-    /// Stm signature
-    pub sig: StmSig,
-    /// Registered party
-    pub reg_party: RegParty,
-}
-
-impl StmSigRegParty {
-    /// Convert StmSigRegParty to bytes
-    /// # Layout
-    /// * RegParty
-    /// * Signature
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let mut out = Vec::new();
-        out.extend_from_slice(&self.reg_party.to_bytes());
-        out.extend_from_slice(&self.sig.to_bytes());
-
-        out
-    }
-    ///Extract a `StmSigRegParty` from a byte slice.
-    pub fn from_bytes<D: Digest + Clone + FixedOutput>(
-        bytes: &[u8],
-    ) -> Result<StmSigRegParty, StmSignatureError> {
-        let reg_party = RegParty::from_bytes(&bytes[0..104])?;
-        let sig = StmSig::from_bytes::<D>(&bytes[104..])?;
-
-        Ok(StmSigRegParty { sig, reg_party })
-    }
-}
-
-impl Serialize for StmSigRegParty {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut tuple = serializer.serialize_tuple(2)?;
-        tuple.serialize_element(&self.sig)?;
-        tuple.serialize_element(&self.reg_party)?;
-        tuple.end()
-    }
-}
-
 /// `StmClerk` can verify and aggregate `StmSig`s and verify `StmMultiSig`s.
 /// Clerks can only be generated with the registration closed.
 /// This avoids that a Merkle Tree is computed before all parties have registered.