moved aggration errors to aggregate_signature

Author: damrobi

mithril-common/src/protocol/multi_signer.rs

@@ -91,7 +91,7 @@ impl MultiSigner {
 
 #[cfg(test)]
 mod test {
-    use mithril_stm::MultiSignatureError;
+    use mithril_stm::BlsSignatureError;
 
     use crate::{
         crypto_helper::ProtocolAggregationError,
@@ -195,8 +195,8 @@ mod test {
                 "Verify single signature should fail if the signer isn't in the registered parties",
             );
 
-        match error.downcast_ref::<MultiSignatureError>() {
-            Some(MultiSignatureError::SignatureInvalid(_)) => (),
+        match error.downcast_ref::<BlsSignatureError>() {
+            Some(BlsSignatureError::SignatureInvalid(_)) => (),
             _ => panic!("Expected an SignatureInvalid error, got: {error:?}"),
         }
     }
@@ -221,8 +221,8 @@ mod test {
             .verify_single_signature(&ProtocolMessage::default(), &single_signature)
             .expect_err("Verify single signature should fail");
 
-        match error.downcast_ref::<MultiSignatureError>() {
-            Some(MultiSignatureError::SignatureInvalid(_)) => (),
+        match error.downcast_ref::<BlsSignatureError>() {
+            Some(BlsSignatureError::SignatureInvalid(_)) => (),
             _ => panic!("Expected an SignatureInvalid error, got: {error:?}"),
         }
     }

mithril-stm/src/lib.rs

@@ -117,6 +117,7 @@ mod protocol;
 mod signature_scheme;
 
 pub use protocol::*;
+pub use signature_scheme::BlsSignatureError;
 
 #[cfg(feature = "benchmark-internals")]
 pub use signature_scheme::{

mithril-stm/src/protocol/aggregate_signature/basic_verifier.rs

@@ -1,9 +1,10 @@
 use anyhow::{Context, anyhow};
 use std::collections::{BTreeMap, HashMap, HashSet};
 
+use super::AggregationError;
 use crate::{
-    AggregationError, Index, Parameters, RegisteredParty, SingleSignature,
-    SingleSignatureWithRegisteredParty, Stake, StmResult,
+    Index, Parameters, RegisteredParty, SingleSignature, SingleSignatureWithRegisteredParty, Stake,
+    StmResult,
     membership_commitment::MerkleTreeLeaf,
     signature_scheme::{BlsSignature, BlsVerificationKey},
 };

mithril-stm/src/protocol/aggregate_signature/clerk.rs

@@ -5,7 +5,7 @@ use blake2::digest::{Digest, FixedOutput};
 use anyhow::anyhow;
 
 #[cfg(feature = "future_proof_system")]
-use crate::AggregationError;
+use super::AggregationError;
 
 use super::{AggregateSignature, AggregateSignatureType, AggregateVerificationKey};
 use crate::{

mithril-stm/src/protocol/aggregate_signature/error.rs

@@ -0,0 +1,32 @@
+use crate::AggregateSignatureType;
+
+/// Error types for aggregation.
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum AggregationError {
+    /// Not enough signatures were collected, got this many instead.
+    #[error("Not enough signatures. Got only {0} out of {1}.")]
+    NotEnoughSignatures(u64, u64),
+
+    #[error("Unsupported proof system: {0}")]
+    UnsupportedProofSystem(AggregateSignatureType),
+
+    /// There is a duplicate index
+    #[error("Indices are not unique.")]
+    IndexNotUnique,
+}
+
+/// Errors which can be output by Mithril aggregate verification.
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum AggregateSignatureError {
+    /// This error occurs when the the serialization of the raw bytes failed
+    #[error("Invalid bytes")]
+    SerializationError,
+
+    /// Batch verification of STM aggregate signatures failed
+    #[error("Batch verification of STM aggregate signatures failed")]
+    BatchInvalid,
+
+    /// The proof system used in the aggregate signature is not supported
+    #[error("Unsupported proof system: {0}")]
+    UnsupportedProofSystem(AggregateSignatureType),
+}

mithril-stm/src/protocol/aggregate_signature/mod.rs

@@ -1,11 +1,13 @@
 mod aggregate_key;
 mod basic_verifier;
 mod clerk;
+mod error;
 mod signature;
 
 pub use aggregate_key::*;
 pub use basic_verifier::*;
 pub use clerk::*;
+pub use error::*;
 pub use signature::*;
 
 #[cfg(test)]
@@ -20,9 +22,11 @@ mod tests {
     use rand_core::{RngCore, SeedableRng};
     use std::collections::{HashMap, HashSet};
 
-    use super::{AggregateSignature, AggregateSignatureType, BasicVerifier, Clerk};
+    use super::{
+        AggregateSignature, AggregateSignatureType, AggregationError, BasicVerifier, Clerk,
+    };
     use crate::{
-        AggregationError, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
+        Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
         SingleSignatureWithRegisteredParty, Stake, StmResult,
         membership_commitment::MerkleBatchPath, signature_scheme::BlsVerificationKey,
     };

mithril-stm/src/protocol/aggregate_signature/signature.rs

@@ -4,10 +4,10 @@ use anyhow::anyhow;
 use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
-use super::AggregateVerificationKey;
+use super::{AggregateSignatureError, AggregateVerificationKey};
 use crate::{
-    AggregateSignatureError, Parameters, StmError, StmResult,
-    membership_commitment::MerkleBatchPath, proof_system::ConcatenationProof,
+    Parameters, StmError, StmResult, membership_commitment::MerkleBatchPath,
+    proof_system::ConcatenationProof,
 };
 
 /// The type of STM aggregate signature.

mithril-stm/src/protocol/error.rs

@@ -71,36 +71,36 @@ pub enum SignatureError {
     SerializationError,
 }
 
-/// Error types for aggregation.
-#[derive(Debug, Clone, thiserror::Error)]
-pub enum AggregationError {
-    /// Not enough signatures were collected, got this many instead.
-    #[error("Not enough signatures. Got only {0} out of {1}.")]
-    NotEnoughSignatures(u64, u64),
+// /// Error types for aggregation.
+// #[derive(Debug, Clone, thiserror::Error)]
+// pub enum AggregationError {
+//     /// Not enough signatures were collected, got this many instead.
+//     #[error("Not enough signatures. Got only {0} out of {1}.")]
+//     NotEnoughSignatures(u64, u64),
 
-    #[error("Unsupported proof system: {0}")]
-    UnsupportedProofSystem(AggregateSignatureType),
+//     #[error("Unsupported proof system: {0}")]
+//     UnsupportedProofSystem(AggregateSignatureType),
 
-    /// There is a duplicate index
-    #[error("Indices are not unique.")]
-    IndexNotUnique,
-}
+//     /// There is a duplicate index
+//     #[error("Indices are not unique.")]
+//     IndexNotUnique,
+// }
 
-/// Errors which can be output by Mithril aggregate verification.
-#[derive(Debug, Clone, thiserror::Error)]
-pub enum AggregateSignatureError {
-    /// This error occurs when the the serialization of the raw bytes failed
-    #[error("Invalid bytes")]
-    SerializationError,
+// /// Errors which can be output by Mithril aggregate verification.
+// #[derive(Debug, Clone, thiserror::Error)]
+// pub enum AggregateSignatureError {
+//     /// This error occurs when the the serialization of the raw bytes failed
+//     #[error("Invalid bytes")]
+//     SerializationError,
 
-    /// Batch verification of STM aggregate signatures failed
-    #[error("Batch verification of STM aggregate signatures failed")]
-    BatchInvalid,
+//     /// Batch verification of STM aggregate signatures failed
+//     #[error("Batch verification of STM aggregate signatures failed")]
+//     BatchInvalid,
 
-    /// The proof system used in the aggregate signature is not supported
-    #[error("Unsupported proof system: {0}")]
-    UnsupportedProofSystem(AggregateSignatureType),
-}
+//     /// The proof system used in the aggregate signature is not supported
+//     #[error("Unsupported proof system: {0}")]
+//     UnsupportedProofSystem(AggregateSignatureType),
+// }
 
 /// Errors which can be outputted by key registration.
 #[derive(Debug, Clone, thiserror::Error, PartialEq, Eq)]

mithril-stm/src/protocol/mod.rs

@@ -7,10 +7,11 @@ mod participant;
 mod single_signature;
 
 pub use aggregate_signature::{
-    AggregateSignature, AggregateSignatureType, AggregateVerificationKey, BasicVerifier, Clerk,
+    AggregateSignature, AggregateSignatureError, AggregateSignatureType, AggregateVerificationKey,
+    AggregationError, BasicVerifier, Clerk,
 };
 pub(crate) use eligibility_check::is_lottery_won;
-pub use error::{AggregateSignatureError, AggregationError, RegisterError, SignatureError};
+pub use error::{RegisterError, SignatureError};
 pub use key_registration::{ClosedKeyRegistration, KeyRegistration, RegisteredParty};
 pub use parameters::Parameters;
 pub use participant::{Initializer, Signer, VerificationKey, VerificationKeyProofOfPossession};