Merge pull request #2602 from input-output-hk/curiecrypt/rename-stm-structs

Enhance STM library readability - Rename Structs

Author: curiecrypt

demo/protocol-demo/src/types.rs

@@ -11,29 +11,29 @@ type D = Blake2b<U32>;
 /// The id of a mithril party.
 pub type ProtocolPartyId = String;
 
-/// Alias of [MithrilStm:Stake](type@mithril_stm::stm::Stake).
+/// Alias of [MithrilStm:Stake](type@mithril_stm::Stake).
 pub type ProtocolStake = Stake;
 
-/// Alias of [MithrilStm::StmParameters](struct@mithril_stm::stm::StmParameters).
+/// Alias of [MithrilStm::StmParameters](struct@mithril_stm::StmParameters).
 pub type ProtocolParameters = StmParameters;
 
-/// Alias of [MithrilStm:StmSigner](struct@mithril_stm::stm::StmSigner).
+/// Alias of [MithrilStm:StmSigner](struct@mithril_stm::StmSigner).
 pub type ProtocolSigner = StmSigner<D>;
 
-/// Alias of [MithrilStm:StmClerk](struct@mithril_stm::stm::StmClerk).
+/// Alias of [MithrilStm:StmClerk](struct@mithril_stm::StmClerk).
 pub type ProtocolClerk = StmClerk<D>;
 
-/// Alias of [MithrilStm:StmInitializer](struct@mithril_stm::stm::StmInitializer).
+/// Alias of [MithrilStm:StmInitializer](struct@mithril_stm::StmInitializer).
 pub type ProtocolInitializerNotCertified = StmInitializer;
 
-/// Alias of [MithrilStm:KeyReg](struct@mithril_stm::key_reg::KeyReg). (Test only)
+/// Alias of [MithrilStm:KeyReg](struct@mithril_stm::KeyReg). (Test only)
 pub type ProtocolKeyRegistrationNotCertified = KeyReg;
 
-/// Alias of [MithrilStm:StmSig](struct@mithril_stm::stm::StmSig).
+/// Alias of [MithrilStm:StmSig](struct@mithril_stm::StmSig).
 pub type ProtocolSingleSignature = StmSig;
 
-/// Alias of [MithrilStm:StmAggrSig](struct@mithril_stm::stm::StmAggrSig).
+/// Alias of [MithrilStm:StmAggrSig](struct@mithril_stm::StmAggrSig).
 pub type ProtocolMultiSignature = StmAggrSig<D>;
 
-/// Alias of [MithrilStm:StmVerificationKeyPoP](type@mithril_stm::stm::StmVerificationKeyPoP).
+/// Alias of [MithrilStm:StmVerificationKeyPoP](type@mithril_stm::StmVerificationKeyPoP).
 pub type ProtocolSignerVerificationKey = StmVerificationKeyPoP;

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.4.6 (27-06-2025)
+
+### Changed
+
+- Struct names are changed.
+
 ## 0.4.5 (23-06-2025)
 
 ### Changed

mithril-stm/README.md

@@ -67,7 +67,7 @@ use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 use rayon::prelude::*;
 
-use mithril_stm::{StmClerk, StmParameters, StmSig, KeyReg, StmInitializer, StmSigner, AggregationError};
+use mithril_stm::{StmClerk, Parameters, SingleSignature, KeyRegistration, Initializer, Signer, AggregationError};
 
 type H = Blake2b<U32>;
 
@@ -81,7 +81,7 @@ fn main() {
     // initialization phase //
     //////////////////////////
 
-    let params = StmParameters {
+    let params = Parameters {
         k: 357,
         m: 2642,
         phi_f: 0.2,
@@ -92,11 +92,11 @@ fn main() {
         .map(|_| 1 + (rng.next_u64() % 9999))
         .collect::<Vec<_>>();
 
-    let mut key_reg = KeyReg::init();
+    let mut key_reg = KeyRegistration::init();
 
-    let mut ps: Vec<StmInitializer> = Vec::with_capacity(nparties as usize);
+    let mut ps: Vec<Initializer> = Vec::with_capacity(nparties as usize);
     for stake in parties {
-        let p = StmInitializer::setup(params, stake, &mut rng);
+        let p = Initializer::setup(params, stake, &mut rng);
         key_reg.register(stake, p.verification_key()).unwrap();
         ps.push(p);
     }
@@ -106,7 +106,7 @@ fn main() {
     let ps = ps
         .into_par_iter()
         .map(|p| p.new_signer(closed_reg.clone()).unwrap())
-        .collect::<Vec<StmSigner<H>>>();
+        .collect::<Vec<Signer<H>>>();
 
     /////////////////////
     // operation phase //
@@ -115,7 +115,7 @@ fn main() {
     let sigs = ps
         .par_iter()
         .filter_map(|p| p.sign(&msg))
-        .collect::<Vec<StmSig>>();
+        .collect::<Vec<SingleSignature>>();
 
     let clerk = StmClerk::from_signer(&ps[0]);
     let avk = clerk.compute_avk();

mithril-stm/benches/multi_sig.rs

@@ -1,6 +1,6 @@
 use blake2::{digest::consts::U64, Blake2b, Digest};
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use mithril_stm::{Signature, SigningKey, VerificationKey};
+use mithril_stm::{BlsSignature, BlsSigningKey, BlsVerificationKey};
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 
@@ -20,21 +20,21 @@ fn batch_benches(c: &mut Criterion, array_batches: &[usize], nr_sigs: usize) {
             let mut mvks = Vec::new();
             let mut sigs = Vec::new();
             for _ in 0..nr_sigs {
-                let sk = SigningKey::generate(&mut rng);
-                let vk = VerificationKey::from(&sk);
+                let sk = BlsSigningKey::generate(&mut rng);
+                let vk = BlsVerificationKey::from(&sk);
                 let sig = sk.sign(&msg);
                 sigs.push(sig);
                 mvks.push(vk);
             }
-            let (agg_vk, agg_sig) = Signature::aggregate(&mvks, &sigs).unwrap();
+            let (agg_vk, agg_sig) = BlsSignature::aggregate(&mvks, &sigs).unwrap();
             batch_msgs.push(msg.to_vec());
             batch_vk.push(agg_vk);
             batch_sig.push(agg_sig);
         }
 
         group.bench_function(BenchmarkId::new("Batch Verification", batch_string), |b| {
             b.iter(|| {
-                Signature::batch_verify_aggregates(&batch_msgs, &batch_vk, &batch_sig).is_ok()
+                BlsSignature::batch_verify_aggregates(&batch_msgs, &batch_vk, &batch_sig).is_ok()
             })
         });
     }
@@ -49,8 +49,8 @@ fn aggregate_and_verify(c: &mut Criterion, nr_sigs: usize) {
     let mut mvks = Vec::new();
     let mut sigs = Vec::new();
     for _ in 0..nr_sigs {
-        let sk = SigningKey::generate(&mut rng);
-        let vk = VerificationKey::from(&sk);
+        let sk = BlsSigningKey::generate(&mut rng);
+        let vk = BlsVerificationKey::from(&sk);
         let sig = sk.sign(&msg);
         sigs.push(sig);
         mvks.push(vk);
@@ -71,7 +71,7 @@ fn aggregate_and_verify(c: &mut Criterion, nr_sigs: usize) {
                 hasher.update(sig.to_bytes());
                 hasher.finalize();
             }
-            let (agg_vk, agg_sig) = Signature::aggregate(&mvks, &sigs).unwrap();
+            let (agg_vk, agg_sig) = BlsSignature::aggregate(&mvks, &sigs).unwrap();
             assert!(agg_sig.verify(&msg, &agg_vk).is_ok())
         })
     });

mithril-stm/benches/size_benches.rs

@@ -4,8 +4,8 @@ use blake2::{
     Blake2b, Digest,
 };
 use mithril_stm::{
-    CoreVerifier, KeyReg, Stake, StmClerk, StmInitializer, StmParameters, StmSig, StmSigRegParty,
-    StmSigner, StmVerificationKey,
+    BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
+    SingleSignatureWithRegisteredParty, Stake, VerificationKey,
 };
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
@@ -27,12 +27,12 @@ where
         .map(|_| 1 + (rng.next_u64() % 9999))
         .collect::<Vec<_>>();
 
-    let mut ps: Vec<StmInitializer> = Vec::with_capacity(nparties);
-    let params = StmParameters { k, m, phi_f: 0.2 };
+    let mut ps: Vec<Initializer> = Vec::with_capacity(nparties);
+    let params = Parameters { k, m, phi_f: 0.2 };
 
-    let mut key_reg = KeyReg::init();
+    let mut key_reg = KeyRegistration::init();
     for stake in parties {
-        let p = StmInitializer::setup(params, stake, &mut rng);
+        let p = Initializer::setup(params, stake, &mut rng);
         key_reg.register(stake, p.verification_key()).unwrap();
         ps.push(p);
     }
@@ -42,13 +42,13 @@ where
     let ps = ps
         .into_par_iter()
         .map(|p| p.new_signer(closed_reg.clone()).unwrap())
-        .collect::<Vec<StmSigner<H>>>();
+        .collect::<Vec<Signer<H>>>();
 
     let sigs = ps
         .par_iter()
         .filter_map(|p| p.sign(&msg))
-        .collect::<Vec<StmSig>>();
-    let clerk = StmClerk::from_signer(&ps[0]);
+        .collect::<Vec<SingleSignature>>();
+    let clerk = Clerk::from_signer(&ps[0]);
 
     // Aggregate with random parties
     let aggr = clerk.aggregate(&sigs, &msg).unwrap();
@@ -70,29 +70,29 @@ where
     let mut msg = [0u8; 16];
     rng.fill_bytes(&mut msg);
 
-    let mut public_signers: Vec<(StmVerificationKey, Stake)> = Vec::with_capacity(nparties);
-    let mut initializers: Vec<StmInitializer> = Vec::with_capacity(nparties);
+    let mut public_signers: Vec<(VerificationKey, Stake)> = Vec::with_capacity(nparties);
+    let mut initializers: Vec<Initializer> = Vec::with_capacity(nparties);
 
     let parties = (0..nparties)
         .map(|_| 1 + (rng.next_u64() % 9999))
         .collect::<Vec<_>>();
 
-    let params = StmParameters { k, m, phi_f: 0.2 };
+    let params = Parameters { k, m, phi_f: 0.2 };
 
     for stake in parties {
-        let initializer = StmInitializer::setup(params, stake, &mut rng);
+        let initializer = Initializer::setup(params, stake, &mut rng);
         initializers.push(initializer.clone());
         public_signers.push((initializer.verification_key().vk, initializer.stake));
     }
 
-    let core_verifier = CoreVerifier::setup(&public_signers);
+    let core_verifier = BasicVerifier::setup(&public_signers);
 
-    let signers: Vec<StmSigner<H>> = initializers
+    let signers: Vec<Signer<H>> = initializers
         .into_iter()
         .filter_map(|s| s.new_core_signer(&core_verifier.eligible_parties))
         .collect();
 
-    let mut signatures: Vec<StmSig> = Vec::with_capacity(nparties);
+    let mut signatures: Vec<SingleSignature> = Vec::with_capacity(nparties);
     for s in signers {
         if let Some(sig) = s.core_sign(&msg, core_verifier.total_stake) {
             signatures.push(sig);
@@ -101,13 +101,13 @@ where
 
     let sig_reg_list = signatures
         .iter()
-        .map(|sig| StmSigRegParty {
+        .map(|sig| SingleSignatureWithRegisteredParty {
             sig: sig.clone(),
             reg_party: core_verifier.eligible_parties[sig.signer_index as usize],
         })
-        .collect::<Vec<StmSigRegParty>>();
+        .collect::<Vec<SingleSignatureWithRegisteredParty>>();
 
-    let dedup_sigs = CoreVerifier::dedup_sigs_for_indices(
+    let dedup_sigs = BasicVerifier::dedup_sigs_for_indices(
         &core_verifier.total_stake,
         &params,
         &msg,