change log and crates version

curiecrypt · curiecrypt · commit d547f20c9710 · 2025-11-20T15:21:38.000+03:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/mithril-stm/CHANGELOG.md b/mithril-stm/CHANGELOG.md
@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.6.0 (11-19-2025)
+
+### Changed
+
+- Stm error handling is done with `anyhow`.
+
 ## 0.5.5 (10-13-2025)
 
 ### Fixed
diff --git a/mithril-stm/Cargo.toml b/mithril-stm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mithril-stm"
-version = "0.5.5"
+version = "0.6.0"
 edition = { workspace = true }
 authors = { workspace = true }
 homepage = { workspace = true }
diff --git a/mithril-stm/README.md b/mithril-stm/README.md
@@ -141,9 +141,7 @@ match msig {
             println!("Not enough signatures");
             assert!(n < &params.k && k == &params.k)
         },
-        // Some(AggregationError::UsizeConversionInvalid) => {
-        //     println!("Invalid usize conversion");
-        // },
+
         Some(AggregationError::UnsupportedProofSystem(aggregate_signature_type)) => {
             println!("Unsupported proof system: {:?}", aggregate_signature_type);
         },
diff --git a/mithril-stm/src/aggregate_signature/mod.rs b/mithril-stm/src/aggregate_signature/mod.rs
@@ -267,14 +267,11 @@ mod tests {
                         println!("Not enough signatures");
                         assert!(n < &params.k && k == &params.k)
                     },
-                    // Some(AggregationError::UsizeConversionInvalid) => {
-                    //     println!("Invalid usize conversion");
-                    // },
                     Some(AggregationError::UnsupportedProofSystem(aggregate_signature_type)) => {
-                        println!("Unsupported proof system: {:?}", aggregate_signature_type);
+                        panic!("Unsupported proof system: {:?}", aggregate_signature_type);
                     },
                     _ => {
-                        println!("Unexpected error during aggregation: {:?}", error);
+                        panic!("Unexpected error during aggregation: {:?}", error);
                     }
                 },
             }
diff --git a/mithril-stm/src/aggregate_signature/proof/concatenation.rs b/mithril-stm/src/aggregate_signature/proof/concatenation.rs
@@ -8,8 +8,8 @@ use crate::bls_multi_signature::{BlsSignature, BlsVerificationKey};
 use crate::key_registration::RegisteredParty;
 use crate::merkle_tree::MerkleBatchPath;
 use crate::{
-    AggregateVerificationKey, BasicVerifier, Parameters, SingleSignature,
-    SingleSignatureWithRegisteredParty, StmAggregateSignatureError, StmResult,
+    AggregateSignatureError, AggregateVerificationKey, BasicVerifier, Parameters, SingleSignature,
+    SingleSignatureWithRegisteredParty, StmResult,
 };
 
 /// `ConcatenationProof` uses the "concatenation" proving system (as described in Section 4.3 of the original paper.)
@@ -211,25 +211,25 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> ConcatenationProof<D> {
         u64_bytes.copy_from_slice(
             bytes
                 .get(bytes_index..bytes_index + 8)
-                .ok_or(StmAggregateSignatureError::SerializationError)?,
+                .ok_or(AggregateSignatureError::SerializationError)?,
         );
         let total_sigs = usize::try_from(u64::from_be_bytes(u64_bytes))
-            .map_err(|_| StmAggregateSignatureError::SerializationError)?;
+            .map_err(|_| AggregateSignatureError::SerializationError)?;
         bytes_index += 8;
 
         let mut sig_reg_list = Vec::with_capacity(total_sigs);
         for _ in 0..total_sigs {
             u64_bytes.copy_from_slice(
                 bytes
                     .get(bytes_index..bytes_index + 8)
-                    .ok_or(StmAggregateSignatureError::SerializationError)?,
+                    .ok_or(AggregateSignatureError::SerializationError)?,
             );
             let sig_reg_size = usize::try_from(u64::from_be_bytes(u64_bytes))
-                .map_err(|_| StmAggregateSignatureError::SerializationError)?;
+                .map_err(|_| AggregateSignatureError::SerializationError)?;
             let sig_reg = SingleSignatureWithRegisteredParty::from_bytes::<D>(
                 bytes
                     .get(bytes_index + 8..bytes_index + 8 + sig_reg_size)
-                    .ok_or(StmAggregateSignatureError::SerializationError)?,
+                    .ok_or(AggregateSignatureError::SerializationError)?,
             )?;
             bytes_index += 8 + sig_reg_size;
             sig_reg_list.push(sig_reg);
@@ -238,7 +238,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> ConcatenationProof<D> {
         let batch_proof = MerkleBatchPath::from_bytes(
             bytes
                 .get(bytes_index..)
-                .ok_or(StmAggregateSignatureError::SerializationError)?,
+                .ok_or(AggregateSignatureError::SerializationError)?,
         )?;
 
         Ok(ConcatenationProof {
diff --git a/mithril-stm/src/aggregate_signature/signature.rs b/mithril-stm/src/aggregate_signature/signature.rs
@@ -1,12 +1,12 @@
-use anyhow::anyhow;
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::hash::Hash;
 
+use anyhow::anyhow;
 use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
-use crate::error::StmAggregateSignatureError;
+use crate::error::AggregateSignatureError;
 use crate::merkle_tree::MerkleBatchPath;
 use crate::{AggregateVerificationKey, Parameters, StmResult};
 
@@ -103,7 +103,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
             }
             #[cfg(feature = "future_proof_system")]
             AggregateSignature::Future => Err(anyhow!(
-                StmAggregateSignatureError::UnsupportedProofSystem(self.into())
+                AggregateSignatureError::UnsupportedProofSystem(self.into())
             )),
         }
     }
@@ -131,7 +131,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
                             .filter_map(|s| s.to_concatenation_proof().cloned())
                             .collect::<Vec<_>>();
                         if concatenation_proofs.len() != aggregate_signatures_length {
-                            return Err(anyhow!(StmAggregateSignatureError::BatchInvalid));
+                            return Err(anyhow!(AggregateSignatureError::BatchInvalid));
                         }
 
                         ConcatenationProof::batch_verify(
@@ -142,14 +142,12 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
                         )
                     }
                     #[cfg(feature = "future_proof_system")]
-                    AggregateSignatureType::Future => {
-                        Err(anyhow!(StmAggregateSignatureError::UnsupportedProofSystem(
-                            aggregate_signature_type
-                        )))
-                    }
+                    AggregateSignatureType::Future => Err(anyhow!(
+                        AggregateSignatureError::UnsupportedProofSystem(aggregate_signature_type)
+                    )),
                 }
             })
-            .map_err(|_| anyhow!(StmAggregateSignatureError::BatchInvalid))
+
     }
 
     /// Convert an aggregate signature to bytes
@@ -173,11 +171,10 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
 
     /// Extract an aggregate signature from a byte slice.
     pub fn from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        let proof_type_byte =
-            bytes.first().ok_or(StmAggregateSignatureError::SerializationError)?;
+        let proof_type_byte = bytes.first().ok_or(AggregateSignatureError::SerializationError)?;
         let proof_bytes = &bytes[1..];
         let proof_type = AggregateSignatureType::from_byte_encoding_prefix(*proof_type_byte)
-            .ok_or(StmAggregateSignatureError::SerializationError)?;
+            .ok_or(AggregateSignatureError::SerializationError)?;
         match proof_type {
             AggregateSignatureType::Concatenation => Ok(AggregateSignature::Concatenation(
                 ConcatenationProof::from_bytes(proof_bytes)?,
diff --git a/mithril-stm/src/bls_multi_signature/mod.rs b/mithril-stm/src/bls_multi_signature/mod.rs
@@ -94,6 +94,7 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use rand_core::{RngCore, SeedableRng};
 
+    use crate::RegisterError;
     use crate::bls_multi_signature::helper::unsafe_helpers::{p1_affine_to_sig, p2_affine_to_vk};
     use crate::error::MultiSignatureError;
     use crate::key_registration::KeyRegistration;
@@ -199,8 +200,8 @@ mod tests {
 
             assert!(
                 matches!(
-                    error.downcast_ref::<MultiSignatureError>(),
-                    Some(MultiSignatureError::VerificationKeyInfinity(_))
+                    error.downcast_ref::<RegisterError>(),
+                    Some(RegisterError::KeyInvalid(_))
                 ),
                 "Unexpected error: {error:?}");
         }
diff --git a/mithril-stm/src/error.rs b/mithril-stm/src/error.rs
@@ -58,7 +58,7 @@ pub enum MerkleTreeError {
 
 /// Errors which can be output by Mithril single signature verification.
 #[derive(Debug, Clone, thiserror::Error)]
-pub enum StmSignatureError {
+pub enum SignatureError {
     /// There is an index out of bounds
     #[error("Received index, {0}, is higher than what the security parameter allows, {1}.")]
     IndexBoundFailed(u64, u64),
@@ -89,7 +89,7 @@ pub enum AggregationError {
 
 /// Errors which can be output by Mithril aggregate verification.
 #[derive(Debug, Clone, thiserror::Error)]
-pub enum StmAggregateSignatureError {
+pub enum AggregateSignatureError {
     /// This error occurs when the the serialization of the raw bytes failed
     #[error("Invalid bytes")]
     SerializationError,
diff --git a/mithril-stm/src/key_registration.rs b/mithril-stm/src/key_registration.rs
@@ -38,7 +38,8 @@ impl KeyRegistration {
         pk: BlsVerificationKeyProofOfPossession,
     ) -> StmResult<()> {
         if let Entry::Vacant(e) = self.keys.entry(pk.vk) {
-            pk.verify_proof_of_possession()?;
+            pk.verify_proof_of_possession()
+                .map_err(|_| RegisterError::KeyInvalid(Box::new(pk)))?;
             e.insert(stake);
             return Ok(());
         }
@@ -141,7 +142,7 @@ mod tests {
                             assert_eq!(fake_it, 0);
                             assert!(a.verify_proof_of_possession().is_err());
                         },
-                        _ => {println!("Unexpected error: {error}")}
+                        _ => {panic!("Unexpected error: {error}")}
                     }
                 }
             }
diff --git a/mithril-stm/src/lib.rs b/mithril-stm/src/lib.rs
@@ -125,8 +125,7 @@ pub use aggregate_signature::{
     AggregateSignature, AggregateSignatureType, AggregateVerificationKey, BasicVerifier, Clerk,
 };
 pub use error::{
-    AggregationError, MultiSignatureError, RegisterError, StmAggregateSignatureError,
-    StmSignatureError,
+    AggregateSignatureError, AggregationError, MultiSignatureError, RegisterError, SignatureError,
 };
 pub use key_registration::{ClosedKeyRegistration, KeyRegistration};
 pub use parameters::Parameters;
diff --git a/mithril-stm/src/single_signature/signature.rs b/mithril-stm/src/single_signature/signature.rs
@@ -9,8 +9,7 @@ use serde::{Deserialize, Serialize};
 use crate::bls_multi_signature::BlsSignature;
 use crate::eligibility_check::is_lottery_won;
 use crate::{
-    AggregateVerificationKey, Index, Parameters, Stake, StmResult, StmSignatureError,
-    VerificationKey,
+    AggregateVerificationKey, Index, Parameters, SignatureError, Stake, StmResult, VerificationKey,
 };
 use anyhow::{Context, anyhow};
 
@@ -57,15 +56,13 @@ impl SingleSignature {
     ) -> StmResult<()> {
         for &index in &self.indexes {
             if index > params.m {
-                return Err(anyhow!(StmSignatureError::IndexBoundFailed(
-                    index, params.m
-                )));
+                return Err(anyhow!(SignatureError::IndexBoundFailed(index, params.m)));
             }
 
             let ev = self.sigma.evaluate_dense_mapping(msg, index);
 
             if !is_lottery_won(params.phi_f, ev, *stake, *total_stake) {
-                return Err(anyhow!(StmSignatureError::LotteryLost));
+                return Err(anyhow!(SignatureError::LotteryLost));
             }
         }
 
@@ -99,15 +96,15 @@ impl SingleSignature {
     pub fn from_bytes<D: Clone + Digest + FixedOutput>(bytes: &[u8]) -> StmResult<SingleSignature> {
         let mut u64_bytes = [0u8; 8];
 
-        u64_bytes.copy_from_slice(bytes.get(0..8).ok_or(StmSignatureError::SerializationError)?);
+        u64_bytes.copy_from_slice(bytes.get(0..8).ok_or(SignatureError::SerializationError)?);
         let nr_indexes = u64::from_be_bytes(u64_bytes) as usize;
 
         let mut indexes = Vec::new();
         for i in 0..nr_indexes {
             u64_bytes.copy_from_slice(
                 bytes
                     .get(8 + i * 8..16 + i * 8)
-                    .ok_or(StmSignatureError::SerializationError)?,
+                    .ok_or(SignatureError::SerializationError)?,
             );
             indexes.push(u64::from_be_bytes(u64_bytes));
         }
@@ -116,13 +113,13 @@ impl SingleSignature {
         let sigma = BlsSignature::from_bytes(
             bytes
                 .get(offset..offset + 48)
-                .ok_or(StmSignatureError::SerializationError)?,
+                .ok_or(SignatureError::SerializationError)?,
         )?;
 
         u64_bytes.copy_from_slice(
             bytes
                 .get(offset + 48..offset + 56)
-                .ok_or(StmSignatureError::SerializationError)?,
+                .ok_or(SignatureError::SerializationError)?,
         );
         let signer_index = u64::from_be_bytes(u64_bytes);
 
diff --git a/mithril-stm/src/single_signature/signature_registered_party.rs b/mithril-stm/src/single_signature/signature_registered_party.rs
@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize, Serializer, ser::SerializeTuple};
 
 use crate::StmResult;
 use crate::key_registration::RegisteredParty;
-use crate::{SingleSignature, StmSignatureError};
+use crate::{SignatureError, SingleSignature};
 
 /// Signature with its registered party.
 #[derive(Debug, Clone, Hash, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
@@ -31,10 +31,10 @@ impl SingleSignatureWithRegisteredParty {
         bytes: &[u8],
     ) -> StmResult<SingleSignatureWithRegisteredParty> {
         let reg_party = RegisteredParty::from_bytes(
-            bytes.get(0..104).ok_or(StmSignatureError::SerializationError)?,
+            bytes.get(0..104).ok_or(SignatureError::SerializationError)?,
         )?;
         let sig = SingleSignature::from_bytes::<D>(
-            bytes.get(104..).ok_or(StmSignatureError::SerializationError)?,
+            bytes.get(104..).ok_or(SignatureError::SerializationError)?,
         )?;
 
         Ok(SingleSignatureWithRegisteredParty { sig, reg_party })
diff --git a/mithril-stm/tests/stm_basic.rs b/mithril-stm/tests/stm_basic.rs
@@ -69,7 +69,7 @@ fn test_core_verifier() {
                 assert!((nr_indices) < &params.k)
             }
             _ => {
-                println!("Unexpected error: {:?}", error);
+                panic!("Unexpected error: {:?}", error);
             }
         },
     }
diff --git a/mithril-stm/tests/stm_protocol.rs b/mithril-stm/tests/stm_protocol.rs
@@ -39,14 +39,12 @@ fn test_full_protocol() {
                 println!("Not enough signatures");
                 assert!(n < &params.k && k == &params.k)
             }
-            // Some(AggregationError::UsizeConversionInvalid) => {
-            //     println!("Invalid usize conversion");
-            // }
+
             Some(AggregationError::UnsupportedProofSystem(aggregate_signature_type)) => {
-                println!("Unsupported proof system: {:?}", aggregate_signature_type);
+                panic!("Unsupported proof system: {:?}", aggregate_signature_type);
             }
             _ => {
-                println!("Unexpected error during aggregation: {:?}", error);
+                panic!("Unexpected error during aggregation: {:?}", error);
             }
         },
     }

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,8 @@ impl KeyRegistration {`
`38`	`38`	`pk: BlsVerificationKeyProofOfPossession,`
`39`	`39`	`) -> StmResult<()> {`
`40`	`40`	`if let Entry::Vacant(e) = self.keys.entry(pk.vk) {`
`41`		`- pk.verify_proof_of_possession()?;`
	`41`	`+ pk.verify_proof_of_possession()`
	`42`	`+ .map_err(\|_\| RegisterError::KeyInvalid(Box::new(pk)))?;`
`42`	`43`	`e.insert(stake);`
`43`	`44`	`return Ok(());`
`44`	`45`	`}`
`@@ -141,7 +142,7 @@ mod tests {`
`141`	`142`	`assert_eq!(fake_it, 0);`
`142`	`143`	`assert!(a.verify_proof_of_possession().is_err());`
`143`	`144`	`},`
`144`		`- _ => {println!("Unexpected error: {error}")}`
	`145`	`+ _ => {panic!("Unexpected error: {error}")}`
`145`	`146`	`}`
`146`	`147`	`}`
`147`	`148`	`}`