Enhance STM library readability - Rename functions

demo/protocol-demo/src/demonstrator.rs

@@ -108,9 +108,11 @@ impl Party {
         }
         let closed_reg = key_reg.close();
 
-        let signer = self.initializer.clone().unwrap().new_signer(closed_reg).unwrap();
+        let signer = self.initializer.clone().unwrap().create_signer(closed_reg).unwrap();
         self.signer = Some(signer);
-        self.clerk = Some(ProtocolClerk::from_signer(self.signer.as_ref().unwrap()));
+        self.clerk = Some(ProtocolClerk::new_clerk_from_signer(
+            self.signer.as_ref().unwrap(),
+        ));
     }
 
     /// Individually sign a message through lottery
@@ -140,7 +142,7 @@ impl Party {
         message: &Vec<u8>,
         signatures: &[ProtocolSingleSignature],
     ) -> Option<&ProtocolMultiSignature> {
-        let msig = self.clerk.as_ref().unwrap().aggregate(signatures, message);
+        let msig = self.clerk.as_ref().unwrap().aggregate_signatures(signatures, message);
         match msig {
             Ok(aggregate_signature) => {
                 println!("Party #{}: aggregate signature computed", self.party_id);
@@ -167,7 +169,7 @@ impl Party {
         match self.get_aggregate(message) {
             Some(msig) => match msig.verify(
                 message,
-                &self.clerk.as_ref().unwrap().compute_avk(),
+                &self.clerk.as_ref().unwrap().compute_aggregate_verification_key(),
                 &self.params.unwrap(),
             ) {
                 Ok(_) => {
@@ -245,7 +247,7 @@ impl Verifier {
         }
         let closed_reg = key_reg.close();
 
-        self.clerk = Some(ProtocolClerk::from_registration(
+        self.clerk = Some(ProtocolClerk::new_clerk_from_closed_key_registration(
             &self.params.unwrap(),
             &closed_reg,
         ));
@@ -259,7 +261,7 @@ impl Verifier {
     ) -> Result<(), String> {
         match msig.verify(
             message,
-            &self.clerk.as_ref().unwrap().compute_avk(),
+            &self.clerk.as_ref().unwrap().compute_aggregate_verification_key(),
             &self.params.unwrap(),
         ) {
             Ok(_) => {
@@ -358,11 +360,14 @@ impl ProtocolDemonstrator for Demonstrator {
         let mut players_artifacts = Vec::new();
         for party in self.parties.iter_mut() {
             let protocol_initializer =
-                ProtocolInitializerNotCertified::setup(self.params.unwrap(), party.stake, rng);
+                ProtocolInitializerNotCertified::new(self.params.unwrap(), party.stake, rng);
             players_artifacts.push(PlayerArtifact {
                 party_id: party.clone().party_id,
                 stake: party.stake,
-                verification_key: key_encode_hex(protocol_initializer.verification_key()).unwrap(),
+                verification_key: key_encode_hex(
+                    protocol_initializer.get_verification_key_proof_of_possession(),
+                )
+                .unwrap(),
                 initializer: key_encode_hex(protocol_initializer.clone()).unwrap(),
             });
             party.initializer = Some(protocol_initializer);

mithril-common/src/certificate_chain/certificate_verifier.rs

@@ -495,9 +495,12 @@ mod tests {
             .collect::<Vec<_>>();
 
         let first_signer = &signers[0].protocol_signer;
-        let clerk = ProtocolClerk::from_signer(first_signer);
-        let aggregate_verification_key = clerk.compute_avk().into();
-        let multi_signature = clerk.aggregate(&single_signatures, &message_hash).unwrap().into();
+        let clerk = ProtocolClerk::new_clerk_from_signer(first_signer);
+        let aggregate_verification_key = clerk.compute_aggregate_verification_key().into();
+        let multi_signature = clerk
+            .aggregate_signatures(&single_signatures, &message_hash)
+            .unwrap()
+            .into();
 
         let verifier = MithrilCertificateVerifier::new(
             TestLogger::stdout(),
@@ -785,9 +788,10 @@ mod tests {
                 .iter()
                 .filter_map(|s| s.protocol_signer.sign(signed_message.as_bytes()))
                 .collect::<Vec<_>>();
-            let clerk = ProtocolClerk::from_signer(&fixture.signers_fixture()[0].protocol_signer);
+            let clerk =
+                ProtocolClerk::new_clerk_from_signer(&fixture.signers_fixture()[0].protocol_signer);
             let modified_multi_signature = clerk
-                .aggregate(&single_signatures, signed_message.as_bytes())
+                .aggregate_signatures(&single_signatures, signed_message.as_bytes())
                 .unwrap();
             modified_certificate.signature = CertificateSignature::MultiSignature(
                 modified_certificate.signed_entity_type(),
@@ -1082,12 +1086,12 @@ mod tests {
                     s_adversary.protocol_signer.sign(signed_message.as_bytes())
                 })
                 .collect::<Vec<_>>();
-            let forged_clerk = ProtocolClerk::from_registration(
+            let forged_clerk = ProtocolClerk::new_clerk_from_closed_key_registration(
                 &forged_protocol_parameters.clone().into(),
                 &fixture.signers_fixture()[0].protocol_closed_key_registration,
             );
             let forged_multi_signature = forged_clerk
-                .aggregate(&forged_single_signatures, signed_message.as_bytes())
+                .aggregate_signatures(&forged_single_signatures, signed_message.as_bytes())
                 .unwrap();
             forged_certificate.signature = CertificateSignature::MultiSignature(
                 forged_certificate.signed_entity_type(),

mithril-common/src/crypto_helper/cardano/key_certification.rs

@@ -120,10 +120,10 @@ impl StmInitializerWrapper {
         stake: Stake,
         rng: &mut R,
     ) -> StdResult<Self> {
-        let stm_initializer = Initializer::setup(params, stake, rng);
+        let stm_initializer = Initializer::new(params, stake, rng);
         let kes_signature = if let Some(kes_signer) = kes_signer {
             let (signature, _op_cert) = kes_signer.sign(
-                &stm_initializer.verification_key().to_bytes(),
+                &stm_initializer.get_verification_key_proof_of_possession().to_bytes(),
                 kes_period.unwrap_or_default(),
             )?;
 
@@ -143,7 +143,7 @@ impl StmInitializerWrapper {
 
     /// Extract the verification key.
     pub fn verification_key(&self) -> VerificationKeyProofOfPossession {
-        self.stm_initializer.verification_key()
+        self.stm_initializer.get_verification_key_proof_of_possession()
     }
 
     /// Extract the verification key signature.
@@ -178,7 +178,7 @@ impl StmInitializerWrapper {
         closed_reg: ClosedKeyRegistration<D>,
     ) -> Result<Signer<D>, ProtocolRegistrationErrorWrapper> {
         self.stm_initializer
-            .new_signer(closed_reg)
+            .create_signer(closed_reg)
             .map_err(ProtocolRegistrationErrorWrapper::CoreRegister)
     }
 
@@ -365,7 +365,10 @@ mod test {
             Some(opcert1),
             initializer_1.verification_key_signature(),
             Some(0),
-            initializer_1.stm_initializer.verification_key().into(),
+            initializer_1
+                .stm_initializer
+                .get_verification_key_proof_of_possession()
+                .into(),
         );
         assert!(key_registration_1.is_ok());
 
@@ -390,7 +393,10 @@ mod test {
             Some(opcert2),
             initializer_2.verification_key_signature(),
             Some(0),
-            initializer_2.stm_initializer.verification_key().into(),
+            initializer_2
+                .stm_initializer
+                .get_verification_key_proof_of_possession()
+                .into(),
         );
         assert!(key_registration_2.is_ok())
     }

mithril-common/src/protocol/multi_signer.rs

@@ -37,13 +37,13 @@ impl MultiSigner {
             .collect();
 
         self.protocol_clerk
-            .aggregate(&protocol_signatures, message.to_message().as_bytes())
+            .aggregate_signatures(&protocol_signatures, message.to_message().as_bytes())
             .map(|multi_sig| multi_sig.into())
     }
 
     /// Compute aggregate verification key from stake distribution
     pub fn compute_aggregate_verification_key(&self) -> ProtocolAggregateVerificationKey {
-        self.protocol_clerk.compute_avk().into()
+        self.protocol_clerk.compute_aggregate_verification_key().into()
     }
 
     /// Verify a single signature
@@ -60,7 +60,7 @@ impl MultiSigner {
         // party, and we can ignore the request.
         let (vk, stake) = self
             .protocol_clerk
-            .get_reg_party(&protocol_signature.signer_index)
+            .get_registered_party_for_index(&protocol_signature.signer_index)
             .ok_or_else(|| {
                 anyhow!(format!(
                     "Unregistered party: '{}'",

mithril-common/src/protocol/signer_builder.rs

@@ -73,19 +73,23 @@ impl SignerBuilder {
     /// Build a [MultiSigner] based on the registered parties
     pub fn build_multi_signer(&self) -> MultiSigner {
         let stm_parameters = self.protocol_parameters.clone().into();
-        let clerk =
-            ProtocolClerk::from_registration(&stm_parameters, &self.closed_key_registration);
+        let clerk = ProtocolClerk::new_clerk_from_closed_key_registration(
+            &stm_parameters,
+            &self.closed_key_registration,
+        );
 
         MultiSigner::new(clerk, stm_parameters)
     }
 
     /// Compute aggregate verification key from stake distribution
     pub fn compute_aggregate_verification_key(&self) -> ProtocolAggregateVerificationKey {
         let stm_parameters = self.protocol_parameters.clone().into();
-        let clerk =
-            ProtocolClerk::from_registration(&stm_parameters, &self.closed_key_registration);
+        let clerk = ProtocolClerk::new_clerk_from_closed_key_registration(
+            &stm_parameters,
+            &self.closed_key_registration,
+        );
 
-        clerk.compute_avk().into()
+        clerk.compute_aggregate_verification_key().into()
     }
 
     fn build_single_signer_with_rng<R: RngCore + CryptoRng>(

mithril-common/src/test_utils/certificate_chain_builder.rs

@@ -350,13 +350,13 @@ impl<'a> CertificateChainBuilder<'a> {
     fn compute_clerk_for_signers(signers: &[SignerFixture]) -> ProtocolClerk {
         let first_signer = &signers[0].protocol_signer;
 
-        ProtocolClerk::from_signer(first_signer)
+        ProtocolClerk::new_clerk_from_signer(first_signer)
     }
 
     fn compute_avk_for_signers(signers: &[SignerFixture]) -> ProtocolAggregateVerificationKey {
         let clerk = Self::compute_clerk_for_signers(signers);
 
-        clerk.compute_avk().into()
+        clerk.compute_aggregate_verification_key().into()
     }
 
     fn setup_genesis() -> (ProtocolGenesisSigner, ProtocolGenesisVerifier) {
@@ -499,7 +499,7 @@ impl<'a> CertificateChainBuilder<'a> {
             .collect::<Vec<_>>();
         let clerk = CertificateChainBuilder::compute_clerk_for_signers(&fixture.signers_fixture());
         let multi_signature = clerk
-            .aggregate(&single_signatures, certificate.signed_message.as_bytes())
+            .aggregate_signatures(&single_signatures, certificate.signed_message.as_bytes())
             .unwrap();
         certificate.signature = CertificateSignature::MultiSignature(
             SignedEntityType::CardanoDatabase(CardanoDbBeacon::new(

mithril-signer/src/services/single_signer.rs

@@ -183,8 +183,8 @@ mod tests {
         let snapshot_digest = "digest".to_string();
         let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
         let current_signer = &fixture.signers_fixture()[0];
-        let clerk = ProtocolClerk::from_signer(&current_signer.protocol_signer);
-        let avk = clerk.compute_avk();
+        let clerk = ProtocolClerk::new_clerk_from_signer(&current_signer.protocol_signer);
+        let avk = clerk.compute_aggregate_verification_key();
         let logger = TestLogger::stdout();
         let connection = Arc::new(main_db_connection().unwrap());
         let stake_store = {
@@ -228,7 +228,7 @@ mod tests {
             decoded_sig
                 .verify(
                     &fixture.protocol_parameters().into(),
-                    &current_signer.protocol_signer.verification_key(),
+                    &current_signer.protocol_signer.get_verification_key(),
                     &current_signer.protocol_signer.get_stake(),
                     &avk,
                     &expected_message

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.9 (07-07-2025)
+
+### Changed
+
+- Function names are changed.
+
 ## 0.4.8 (02-07-2025)
 
 ### Deprecated

mithril-stm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-stm"
-version = "0.4.8"
+version = "0.4.9"
 edition = { workspace = true }
 authors = { workspace = true }
 homepage = { workspace = true }

mithril-stm/benches/size_benches.rs

@@ -30,26 +30,28 @@ where
 
     let mut key_reg = KeyRegistration::init();
     for stake in parties {
-        let p = Initializer::setup(params, stake, &mut rng);
-        key_reg.register(stake, p.verification_key()).unwrap();
+        let p = Initializer::new(params, stake, &mut rng);
+        key_reg
+            .register(stake, p.get_verification_key_proof_of_possession())
+            .unwrap();
         ps.push(p);
     }
 
     let closed_reg = key_reg.close::<H>();
 
     let ps = ps
         .into_par_iter()
-        .map(|p| p.new_signer(closed_reg.clone()).unwrap())
+        .map(|p| p.create_signer(closed_reg.clone()).unwrap())
         .collect::<Vec<Signer<H>>>();
 
     let sigs = ps
         .par_iter()
         .filter_map(|p| p.sign(&msg))
         .collect::<Vec<SingleSignature>>();
-    let clerk = Clerk::from_signer(&ps[0]);
+    let clerk = Clerk::new_clerk_from_signer(&ps[0]);
 
     // Aggregate with random parties
-    let aggr = clerk.aggregate(&sigs, &msg).unwrap();
+    let aggr = clerk.aggregate_signatures(&sigs, &msg).unwrap();
 
     println!(
         "k = {} | m = {} | nr parties = {}; {} bytes",
@@ -76,21 +78,24 @@ where
     let params = Parameters { k, m, phi_f: 0.2 };
 
     for stake in parties {
-        let initializer = Initializer::setup(params, stake, &mut rng);
+        let initializer = Initializer::new(params, stake, &mut rng);
         initializers.push(initializer.clone());
-        public_signers.push((initializer.verification_key().vk, initializer.stake));
+        public_signers.push((
+            initializer.get_verification_key_proof_of_possession().vk,
+            initializer.stake,
+        ));
     }
 
-    let core_verifier = BasicVerifier::setup(&public_signers);
+    let core_verifier = BasicVerifier::new(&public_signers);
 
     let signers: Vec<Signer<H>> = initializers
         .into_iter()
-        .filter_map(|s| s.new_core_signer(&core_verifier.eligible_parties))
+        .filter_map(|s| s.create_basic_signer(&core_verifier.eligible_parties))
         .collect();
 
     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) {
+        if let Some(sig) = s.basic_sign(&msg, core_verifier.total_stake) {
             signatures.push(sig);
         }
     }
@@ -103,7 +108,7 @@ where
         })
         .collect::<Vec<SingleSignatureWithRegisteredParty>>();
 
-    let dedup_sigs = BasicVerifier::dedup_sigs_for_indices(
+    let dedup_sigs = BasicVerifier::select_valid_signatures_for_k_indices(
         &core_verifier.total_stake,
         &params,
         &msg,