modified multisig error to blssig

damrobi · damrobi · commit e48d33746a40 · 2025-12-09T12:33:27.000+01:00
diff --git a/mithril-stm/src/membership_commitment/merkle_tree/error.rs b/mithril-stm/src/membership_commitment/merkle_tree/error.rs
@@ -0,0 +1,15 @@
+/// Error types related to merkle trees.
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum MerkleTreeError {
+    /// Serialization error
+    #[error("Serialization of a merkle tree failed")]
+    SerializationError,
+
+    /// Invalid merkle path
+    #[error("Path does not verify against root")]
+    PathInvalid(Vec<u8>),
+
+    /// Invalid merkle batch path
+    #[error("Batch path does not verify against root")]
+    BatchPathInvalid(Vec<u8>),
+}
diff --git a/mithril-stm/src/membership_commitment/merkle_tree/mod.rs b/mithril-stm/src/membership_commitment/merkle_tree/mod.rs
@@ -1,11 +1,13 @@
 //! Merkle tree implementation for STM
 
 mod commitment;
+mod error;
 mod leaf;
 mod path;
 mod tree;
 
 pub use commitment::*;
+pub use error::*;
 pub use leaf::*;
 pub use path::*;
 pub use tree::*;
diff --git a/mithril-stm/src/protocol/error.rs b/mithril-stm/src/protocol/error.rs
@@ -8,36 +8,36 @@ use crate::{
 };
 
 /// Error types for multi signatures.
-#[derive(Debug, thiserror::Error, Eq, PartialEq)]
-pub enum MultiSignatureError {
-    /// Invalid Single signature
-    #[error("Invalid single signature")]
-    SignatureInvalid(BlsSignature),
+// #[derive(Debug, thiserror::Error, Eq, PartialEq)]
+// pub enum MultiSignatureError {
+//     /// Invalid Single signature
+//     #[error("Invalid single signature")]
+//     SignatureInvalid(BlsSignature),
 
-    /// Invalid aggregate signature
-    #[error("Invalid aggregated signature")]
-    AggregateSignatureInvalid,
+//     /// Invalid aggregate signature
+//     #[error("Invalid aggregated signature")]
+//     AggregateSignatureInvalid,
 
-    /// This error occurs when the the serialization of the raw bytes failed
-    #[error("Invalid bytes")]
-    SerializationError,
+//     /// This error occurs when the the serialization of the raw bytes failed
+//     #[error("Invalid bytes")]
+//     SerializationError,
 
-    /// Incorrect proof of possession
-    #[error("Key with invalid PoP")]
-    KeyInvalid(Box<BlsVerificationKeyProofOfPossession>),
+//     /// Incorrect proof of possession
+//     #[error("Key with invalid PoP")]
+//     KeyInvalid(Box<BlsVerificationKeyProofOfPossession>),
 
-    /// At least one signature in the batch is invalid
-    #[error("One signature in the batch is invalid")]
-    BatchInvalid,
+//     /// At least one signature in the batch is invalid
+//     #[error("One signature in the batch is invalid")]
+//     BatchInvalid,
 
-    /// Single signature is the infinity
-    #[error("Single signature is the infinity")]
-    SignatureInfinity(BlsSignature),
+//     /// Single signature is the infinity
+//     #[error("Single signature is the infinity")]
+//     SignatureInfinity(BlsSignature),
 
-    /// Verification key is the infinity
-    #[error("Verification key is the infinity")]
-    VerificationKeyInfinity(Box<BlsVerificationKey>),
-}
+//     /// Verification key is the infinity
+//     #[error("Verification key is the infinity")]
+//     VerificationKeyInfinity(Box<BlsVerificationKey>),
+// }
 
 /// Error types related to merkle trees.
 #[derive(Debug, Clone, thiserror::Error)]
@@ -122,31 +122,31 @@ pub enum RegisterError {
     UnregisteredInitializer,
 }
 
-pub fn blst_error_to_stm_error(
-    e: BLST_ERROR,
-    sig: Option<BlsSignature>,
-    key: Option<BlsVerificationKey>,
-) -> StmResult<()> {
-    match e {
-        BLST_ERROR::BLST_SUCCESS => Ok(()),
-        BLST_ERROR::BLST_PK_IS_INFINITY => {
-            if let Some(s) = sig {
-                return Err(anyhow!(MultiSignatureError::SignatureInfinity(s)));
-            }
-            if let Some(vk) = key {
-                return Err(anyhow!(MultiSignatureError::VerificationKeyInfinity(
-                    Box::new(vk)
-                )));
-            }
-            Err(anyhow!(MultiSignatureError::SerializationError))
-        }
-        BLST_ERROR::BLST_VERIFY_FAIL => {
-            if let Some(s) = sig {
-                Err(anyhow!(MultiSignatureError::SignatureInvalid(s)))
-            } else {
-                Err(anyhow!(MultiSignatureError::AggregateSignatureInvalid))
-            }
-        }
-        _ => Err(anyhow!(MultiSignatureError::SerializationError)),
-    }
-}
+// pub fn blst_error_to_stm_error(
+//     e: BLST_ERROR,
+//     sig: Option<BlsSignature>,
+//     key: Option<BlsVerificationKey>,
+// ) -> StmResult<()> {
+//     match e {
+//         BLST_ERROR::BLST_SUCCESS => Ok(()),
+//         BLST_ERROR::BLST_PK_IS_INFINITY => {
+//             if let Some(s) = sig {
+//                 return Err(anyhow!(MultiSignatureError::SignatureInfinity(s)));
+//             }
+//             if let Some(vk) = key {
+//                 return Err(anyhow!(MultiSignatureError::VerificationKeyInfinity(
+//                     Box::new(vk)
+//                 )));
+//             }
+//             Err(anyhow!(MultiSignatureError::SerializationError))
+//         }
+//         BLST_ERROR::BLST_VERIFY_FAIL => {
+//             if let Some(s) = sig {
+//                 Err(anyhow!(MultiSignatureError::SignatureInvalid(s)))
+//             } else {
+//                 Err(anyhow!(MultiSignatureError::AggregateSignatureInvalid))
+//             }
+//         }
+//         _ => Err(anyhow!(MultiSignatureError::SerializationError)),
+//     }
+// }
diff --git a/mithril-stm/src/protocol/mod.rs b/mithril-stm/src/protocol/mod.rs
@@ -10,10 +10,8 @@ pub use aggregate_signature::{
     AggregateSignature, AggregateSignatureType, AggregateVerificationKey, BasicVerifier, Clerk,
 };
 pub(crate) use eligibility_check::is_lottery_won;
-pub(crate) use error::blst_error_to_stm_error;
 pub use error::{
-    AggregateSignatureError, AggregationError, MerkleTreeError, MultiSignatureError, RegisterError,
-    SignatureError,
+    AggregateSignatureError, AggregationError, MerkleTreeError, RegisterError, SignatureError,
 };
 pub use key_registration::{ClosedKeyRegistration, KeyRegistration, RegisteredParty};
 pub use parameters::Parameters;
diff --git a/mithril-stm/src/signature_scheme/bls_multi_signature/error.rs b/mithril-stm/src/signature_scheme/bls_multi_signature/error.rs
@@ -0,0 +1,68 @@
+//! Crate specific errors
+use anyhow::anyhow;
+use blst::BLST_ERROR;
+
+use super::{BlsSignature, BlsVerificationKey, BlsVerificationKeyProofOfPossession};
+
+use crate::StmResult;
+
+/// Error types for multi signatures.
+#[derive(Debug, thiserror::Error, Eq, PartialEq)]
+pub enum BlsSignatureError {
+    /// Invalid Single signature
+    #[error("Invalid single signature")]
+    SignatureInvalid(BlsSignature),
+
+    /// Invalid aggregate signature
+    #[error("Invalid aggregated signature")]
+    AggregateSignatureInvalid,
+
+    /// This error occurs when the the serialization of the raw bytes failed
+    #[error("Invalid bytes")]
+    SerializationError,
+
+    /// Incorrect proof of possession
+    #[error("Key with invalid PoP")]
+    KeyInvalid(Box<BlsVerificationKeyProofOfPossession>),
+
+    /// At least one signature in the batch is invalid
+    #[error("One signature in the batch is invalid")]
+    BatchInvalid,
+
+    /// Single signature is the infinity
+    #[error("Single signature is the infinity")]
+    SignatureInfinity(BlsSignature),
+
+    /// Verification key is the infinity
+    #[error("Verification key is the infinity")]
+    VerificationKeyInfinity(Box<BlsVerificationKey>),
+}
+
+pub fn blst_error_to_stm_error(
+    e: BLST_ERROR,
+    sig: Option<BlsSignature>,
+    key: Option<BlsVerificationKey>,
+) -> StmResult<()> {
+    match e {
+        BLST_ERROR::BLST_SUCCESS => Ok(()),
+        BLST_ERROR::BLST_PK_IS_INFINITY => {
+            if let Some(s) = sig {
+                return Err(anyhow!(BlsSignatureError::SignatureInfinity(s)));
+            }
+            if let Some(vk) = key {
+                return Err(anyhow!(BlsSignatureError::VerificationKeyInfinity(
+                    Box::new(vk)
+                )));
+            }
+            Err(anyhow!(BlsSignatureError::SerializationError))
+        }
+        BLST_ERROR::BLST_VERIFY_FAIL => {
+            if let Some(s) = sig {
+                Err(anyhow!(BlsSignatureError::SignatureInvalid(s)))
+            } else {
+                Err(anyhow!(BlsSignatureError::AggregateSignatureInvalid))
+            }
+        }
+        _ => Err(anyhow!(BlsSignatureError::SerializationError)),
+    }
+}
diff --git a/mithril-stm/src/signature_scheme/bls_multi_signature/helper.rs b/mithril-stm/src/signature_scheme/bls_multi_signature/helper.rs
@@ -9,8 +9,8 @@ pub(crate) mod unsafe_helpers {
     };
 
     use crate::{
-        MultiSignatureError::SerializationError,
         StmResult,
+        signature_scheme::bls_multi_signature::error::BlsSignatureError::SerializationError,
         signature_scheme::{BlsProofOfPossession, BlsVerificationKey},
     };
 
diff --git a/mithril-stm/src/signature_scheme/bls_multi_signature/mod.rs b/mithril-stm/src/signature_scheme/bls_multi_signature/mod.rs
@@ -1,11 +1,13 @@
 //! BLST Multi-signature module
 
+mod error;
 pub(super) mod helper;
 mod proof_of_possession;
 mod signature;
 mod signing_key;
 mod verification_key;
 
+pub use error::*;
 pub use proof_of_possession::*;
 pub use signature::*;
 pub use signing_key::*;
@@ -94,8 +96,9 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use rand_core::{RngCore, SeedableRng};
 
+    use super::error::BlsSignatureError;
     use super::helper::unsafe_helpers::{p1_affine_to_sig, p2_affine_to_vk};
-    use crate::{KeyRegistration, MultiSignatureError, RegisterError};
+    use crate::{KeyRegistration, RegisterError};
 
     use super::*;
 
@@ -134,8 +137,8 @@ mod tests {
 
             assert!(
                 matches!(
-                    error.downcast_ref::<MultiSignatureError>(),
-                    Some(MultiSignatureError::SignatureInvalid(_))
+                    error.downcast_ref::<BlsSignatureError>(),
+                    Some(BlsSignatureError::SignatureInvalid(_))
                 ),
                 "Unexpected error: {error:?}");
         }
@@ -152,8 +155,8 @@ mod tests {
             let error = sig_infinity.verify(&msg, &vk).expect_err("Verification should fail");
             assert!(
                 matches!(
-                    error.downcast_ref::<MultiSignatureError>(),
-                    Some(MultiSignatureError::SignatureInfinity(_))
+                    error.downcast_ref::<BlsSignatureError>(),
+                    Some(BlsSignatureError::SignatureInfinity(_))
                 ),
                 "Unexpected error: {error:?}");
         }
@@ -171,8 +174,8 @@ mod tests {
             let error = vkpop_infinity.verify_proof_of_possession().expect_err("VK pop infinity should fail");
             assert!(
                 matches!(
-                    error.downcast_ref::<MultiSignatureError>(),
-                    Some(MultiSignatureError::VerificationKeyInfinity(_))
+                    error.downcast_ref::<BlsSignatureError>(),
+                    Some(BlsSignatureError::VerificationKeyInfinity(_))
                 ),
                 "Unexpected error: {error:?}");
         }
@@ -296,8 +299,8 @@ mod tests {
             let error = BlsSignature::batch_verify_aggregates(&batch_msgs, &batch_vk, &batch_sig).expect_err("Batch verify should fail");
             assert!(
                 matches!(
-                    error.downcast_ref::<MultiSignatureError>(),
-                    Some(MultiSignatureError::BatchInvalid)
+                    error.downcast_ref::<BlsSignatureError>(),
+                    Some(BlsSignatureError::BatchInvalid)
                 ),
                 "Unexpected error: {error:?}");
         }
diff --git a/mithril-stm/src/signature_scheme/bls_multi_signature/proof_of_possession.rs b/mithril-stm/src/signature_scheme/bls_multi_signature/proof_of_possession.rs
@@ -1,10 +1,10 @@
 use blst::{blst_p1, min_sig::Signature as BlstSig};
 
 use super::{
-    BlsSigningKey, POP,
+    BlsSignatureError, BlsSigningKey, POP, blst_error_to_stm_error,
     helper::unsafe_helpers::{compress_p1, scalar_to_pk_in_g1, uncompress_p1},
 };
-use crate::{MultiSignatureError, StmResult, blst_error_to_stm_error};
+use crate::StmResult;
 
 /// MultiSig proof of possession, which contains two elements from G1. However,
 /// the two elements have different types: `k1` is represented as a BlstSig
@@ -35,7 +35,7 @@ impl BlsProofOfPossession {
     /// Deserialize a byte string to a `PublicKeyPoP`.
     pub fn from_bytes(bytes: &[u8]) -> StmResult<Self> {
         let k1 = match BlstSig::from_bytes(
-            bytes.get(..48).ok_or(MultiSignatureError::SerializationError)?,
+            bytes.get(..48).ok_or(BlsSignatureError::SerializationError)?,
         ) {
             Ok(key) => key,
             Err(e) => {
@@ -44,7 +44,7 @@ impl BlsProofOfPossession {
             }
         };
 
-        let k2 = uncompress_p1(bytes.get(48..96).ok_or(MultiSignatureError::SerializationError)?)?;
+        let k2 = uncompress_p1(bytes.get(48..96).ok_or(BlsSignatureError::SerializationError)?)?;
 
         Ok(Self { k1, k2 })
     }
diff --git a/mithril-stm/src/signature_scheme/bls_multi_signature/signature.rs b/mithril-stm/src/signature_scheme/bls_multi_signature/signature.rs
@@ -9,10 +9,10 @@ use digest::consts::U16;
 use std::{cmp::Ordering, iter::Sum};
 
 use super::{
-    BlsVerificationKey,
+    BlsSignatureError, BlsVerificationKey, blst_error_to_stm_error,
     helper::unsafe_helpers::{p1_affine_to_sig, p2_affine_to_vk, sig_to_p1, vk_from_p2_affine},
 };
-use crate::{Index, MultiSignatureError, StmResult, blst_error_to_stm_error};
+use crate::{Index, StmResult};
 
 /// MultiSig signature, which is a wrapper over the `BlstSig` type.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -62,7 +62,7 @@ impl BlsSignature {
     /// # Error
     /// Returns an error if the byte string does not represent a point in the curve.
     pub fn from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        let bytes = bytes.get(..48).ok_or(MultiSignatureError::SerializationError)?;
+        let bytes = bytes.get(..48).ok_or(BlsSignatureError::SerializationError)?;
         match BlstSig::sig_validate(bytes, true) {
             Ok(sig) => Ok(Self(sig)),
             Err(e) => Err(blst_error_to_stm_error(e, None, None)
@@ -95,7 +95,7 @@ impl BlsSignature {
         sigs: &[BlsSignature],
     ) -> StmResult<(BlsVerificationKey, BlsSignature)> {
         if vks.len() != sigs.len() || vks.is_empty() {
-            return Err(anyhow!(MultiSignatureError::AggregateSignatureInvalid));
+            return Err(anyhow!(BlsSignatureError::AggregateSignatureInvalid));
         }
 
         if vks.len() < 2 {
@@ -175,7 +175,7 @@ impl BlsSignature {
             None,
             None,
         )
-        .map_err(|_| anyhow!(MultiSignatureError::BatchInvalid))
+        .map_err(|_| anyhow!(BlsSignatureError::BatchInvalid))
     }
 }
 
diff --git a/mithril-stm/src/signature_scheme/bls_multi_signature/signing_key.rs b/mithril-stm/src/signature_scheme/bls_multi_signature/signing_key.rs
diff --git a/mithril-stm/src/signature_scheme/bls_multi_signature/verification_key.rs b/mithril-stm/src/signature_scheme/bls_multi_signature/verification_key.rs
