deprecate old struct names

Author: curiecrypt

demo/protocol-demo/src/types.rs

@@ -1,6 +1,6 @@
 use mithril_stm::{
-    KeyReg, Stake, StmAggrSig, StmClerk, StmInitializer, StmParameters, StmSig, StmSigner,
-    StmVerificationKeyPoP,
+    AggregateSignature, Clerk, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
+    Stake, VerificationKeyProofOfPossession,
 };
 
 use blake2::{Blake2b, digest::consts::U32};
@@ -14,26 +14,26 @@ pub type ProtocolPartyId = String;
 /// Alias of [MithrilStm:Stake](type@mithril_stm::Stake).
 pub type ProtocolStake = Stake;
 
-/// Alias of [MithrilStm::StmParameters](struct@mithril_stm::StmParameters).
-pub type ProtocolParameters = StmParameters;
+/// Alias of [MithrilStm::Parameters](struct@mithril_stm::Parameters).
+pub type ProtocolParameters = Parameters;
 
-/// Alias of [MithrilStm:StmSigner](struct@mithril_stm::StmSigner).
-pub type ProtocolSigner = StmSigner<D>;
+/// Alias of [MithrilStm:Signer](struct@mithril_stm::Signer).
+pub type ProtocolSigner = Signer<D>;
 
-/// Alias of [MithrilStm:StmClerk](struct@mithril_stm::StmClerk).
-pub type ProtocolClerk = StmClerk<D>;
+/// Alias of [MithrilStm:Clerk](struct@mithril_stm::Clerk).
+pub type ProtocolClerk = Clerk<D>;
 
-/// Alias of [MithrilStm:StmInitializer](struct@mithril_stm::StmInitializer).
-pub type ProtocolInitializerNotCertified = StmInitializer;
+/// Alias of [MithrilStm:Initializer](struct@mithril_stm::Initializer).
+pub type ProtocolInitializerNotCertified = Initializer;
 
-/// Alias of [MithrilStm:KeyReg](struct@mithril_stm::KeyReg). (Test only)
-pub type ProtocolKeyRegistrationNotCertified = KeyReg;
+/// Alias of [MithrilStm:KeyRegistration](struct@mithril_stm::KeyRegistration). (Test only)
+pub type ProtocolKeyRegistrationNotCertified = KeyRegistration;
 
-/// Alias of [MithrilStm:StmSig](struct@mithril_stm::StmSig).
-pub type ProtocolSingleSignature = StmSig;
+/// Alias of [MithrilStm:SingleSignature](struct@mithril_stm::SingleSignature).
+pub type ProtocolSingleSignature = SingleSignature;
 
-/// Alias of [MithrilStm:StmAggrSig](struct@mithril_stm::StmAggrSig).
-pub type ProtocolMultiSignature = StmAggrSig<D>;
+/// Alias of [MithrilStm:AggregateSignature](struct@mithril_stm::AggregateSignature).
+pub type ProtocolMultiSignature = AggregateSignature<D>;
 
-/// Alias of [MithrilStm:StmVerificationKeyPoP](type@mithril_stm::StmVerificationKeyPoP).
-pub type ProtocolSignerVerificationKey = StmVerificationKeyPoP;
+/// Alias of [MithrilStm:VerificationKeyProofOfPossession](type@mithril_stm::VerificationKeyProofOfPossession).
+pub type ProtocolSignerVerificationKey = VerificationKeyProofOfPossession;

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

@@ -1,5 +1,5 @@
 //! API for mithril key certification.
-//! Includes the wrappers for StmInitializer and KeyReg, and ProtocolRegistrationErrorWrapper.
+//! Includes the wrappers for Initializer and KeyRegistration, and ProtocolRegistrationErrorWrapper.
 //! These wrappers allows keeping mithril-stm agnostic to Cardano, while providing some
 //! guarantees that mithril-stm will not be misused in the context of Cardano.  
 
@@ -15,8 +15,8 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use mithril_stm::{
-    ClosedKeyReg, KeyReg, RegisterError, Stake, StmInitializer, StmParameters, StmSigner,
-    StmVerificationKeyPoP,
+    ClosedKeyRegistration, Initializer, KeyRegistration, Parameters, RegisterError, Signer, Stake,
+    VerificationKeyProofOfPossession,
 };
 
 use crate::{
@@ -95,13 +95,13 @@ pub enum ProtocolInitializerErrorWrapper {
     KesMismatch(KesPeriod, KesPeriod),
 }
 
-/// Wrapper structure for [MithrilStm:StmInitializer](mithril_stm::stm::StmInitializer).
+/// Wrapper structure for [MithrilStm:Initializer](mithril_stm::stm::Initializer).
 /// It now obtains a KES signature over the Mithril key. This allows the signers prove
 /// their correct identity with respect to a Cardano PoolID.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct StmInitializerWrapper {
-    /// The StmInitializer
-    stm_initializer: StmInitializer,
+    /// The Initializer
+    stm_initializer: Initializer,
 
     /// The KES signature over the Mithril key
     ///
@@ -110,17 +110,17 @@ pub struct StmInitializerWrapper {
 }
 
 impl StmInitializerWrapper {
-    /// Builds an `StmInitializer` that is ready to register with the key registration service.
+    /// Builds an `Initializer` that is ready to register with the key registration service.
     /// This function generates the signing and verification key with a PoP, signs the verification
     /// key with a provided KES signer implementation, and initializes the structure.
     pub fn setup<R: RngCore + CryptoRng>(
-        params: StmParameters,
+        params: Parameters,
         kes_signer: Option<Arc<dyn KesSigner>>,
         kes_period: Option<KesPeriod>,
         stake: Stake,
         rng: &mut R,
     ) -> StdResult<Self> {
-        let stm_initializer = StmInitializer::setup(params, stake, rng);
+        let stm_initializer = Initializer::setup(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(),
@@ -142,7 +142,7 @@ impl StmInitializerWrapper {
     }
 
     /// Extract the verification key.
-    pub fn verification_key(&self) -> StmVerificationKeyPoP {
+    pub fn verification_key(&self) -> VerificationKeyProofOfPossession {
         self.stm_initializer.verification_key()
     }
 
@@ -163,8 +163,8 @@ impl StmInitializerWrapper {
 
     /// Build the `avk` for the given list of parties.
     ///
-    /// Note that if this StmInitializer was modified *between* the last call to `register`,
-    /// then the resulting `StmSigner` may not be able to produce valid signatures.
+    /// Note that if this Initializer was modified *between* the last call to `register`,
+    /// then the resulting `Signer` may not be able to produce valid signatures.
     ///
     /// Returns a `StmSignerWrapper` specialized to
     /// * this `StmSignerWrapper`'s ID and current stake
@@ -175,8 +175,8 @@ impl StmInitializerWrapper {
     /// This function fails if the initializer is not registered.
     pub fn new_signer(
         self,
-        closed_reg: ClosedKeyReg<D>,
-    ) -> Result<StmSigner<D>, ProtocolRegistrationErrorWrapper> {
+        closed_reg: ClosedKeyRegistration<D>,
+    ) -> Result<Signer<D>, ProtocolRegistrationErrorWrapper> {
         self.stm_initializer
             .new_signer(closed_reg)
             .map_err(ProtocolRegistrationErrorWrapper::CoreRegister)
@@ -201,7 +201,7 @@ impl StmInitializerWrapper {
     /// The function fails if the given string of bytes is not of required size.
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, RegisterError> {
         let stm_initializer =
-            StmInitializer::from_bytes(bytes.get(..256).ok_or(RegisterError::SerializationError)?)?;
+            Initializer::from_bytes(bytes.get(..256).ok_or(RegisterError::SerializationError)?)?;
         let bytes = bytes.get(256..).ok_or(RegisterError::SerializationError)?;
         let kes_signature = if bytes.is_empty() {
             None
@@ -216,14 +216,14 @@ impl StmInitializerWrapper {
     }
 
     cfg_test_tools! {
-        /// Override the protocol parameters of the `StmInitializer` for testing purposes only.
+        /// Override the protocol parameters of the `Initializer` for testing purposes only.
         pub fn override_protocol_parameters(&mut self, protocol_parameters: &ProtocolParameters) {
             self.stm_initializer.params = protocol_parameters.to_owned();
         }
     }
 }
 
-/// Wrapper structure for [MithrilStm:KeyReg](mithril_stm::key_reg::KeyReg).
+/// Wrapper structure for [MithrilStm:KeyRegistration](mithril_stm::key_reg::KeyRegistration).
 /// The wrapper not only contains a map between `Mithril vkey <-> Stake`, but also
 /// a map `PoolID <-> Stake`. This information is recovered from the node state, and
 /// is used to verify the identity of a Mithril signer. Furthermore, the `register` function
@@ -232,7 +232,7 @@ impl StmInitializerWrapper {
 #[derive(Debug, Clone)]
 pub struct KeyRegWrapper {
     kes_verifier: Arc<dyn KesVerifier>,
-    stm_key_reg: KeyReg,
+    stm_key_reg: KeyRegistration,
     stake_distribution: HashMap<ProtocolPartyId, Stake>,
 }
 
@@ -242,7 +242,7 @@ impl KeyRegWrapper {
     pub fn init(stake_dist: &ProtocolStakeDistribution) -> Self {
         Self {
             kes_verifier: Arc::new(KesVerifierStandard),
-            stm_key_reg: KeyReg::init(),
+            stm_key_reg: KeyRegistration::init(),
             stake_distribution: HashMap::from_iter(stake_dist.to_vec()),
         }
     }
@@ -293,8 +293,8 @@ impl KeyRegWrapper {
     }
 
     /// Finalize the key registration.
-    /// This function disables `KeyReg::register`, consumes the instance of `self`, and returns a `ClosedKeyReg`.
-    pub fn close<D: Digest + FixedOutput>(self) -> ClosedKeyReg<D> {
+    /// This function disables `ClosedKeyRegistration::register`, consumes the instance of `self`, and returns a `ClosedKeyRegistration`.
+    pub fn close<D: Digest + FixedOutput>(self) -> ClosedKeyRegistration<D> {
         self.stm_key_reg.close()
     }
 }
@@ -317,7 +317,7 @@ mod test {
 
     #[test]
     fn test_vector_key_reg() {
-        let params = StmParameters {
+        let params = Parameters {
             m: 5,
             k: 5,
             phi_f: 1.0,

mithril-common/src/crypto_helper/codec/binary.rs

@@ -37,95 +37,95 @@ mod binary_mithril_stm {
 
     use digest::consts::U32;
     use mithril_stm::{
-        StmAggrSig, StmAggrVerificationKey, StmInitializer, StmParameters, StmSig, StmSigRegParty,
-        StmVerificationKey, StmVerificationKeyPoP,
+        AggregateSignature, AggregateVerificationKey, Initializer, Parameters, SingleSignature,
+        SingleSignatureWithRegisteredParty, VerificationKey, VerificationKeyProofOfPossession,
     };
 
     use super::*;
 
     type D = Blake2b<U32>;
 
-    impl TryToBytes for StmParameters {
+    impl TryToBytes for Parameters {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for StmParameters {
+    impl TryFromBytes for Parameters {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes(bytes).map_err(|e| e.into())
         }
     }
 
-    impl TryToBytes for StmSig {
+    impl TryToBytes for SingleSignature {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for StmSig {
+    impl TryFromBytes for SingleSignature {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes::<D>(bytes).map_err(|e| e.into())
         }
     }
 
-    impl TryToBytes for StmSigRegParty {
+    impl TryToBytes for SingleSignatureWithRegisteredParty {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for StmSigRegParty {
+    impl TryFromBytes for SingleSignatureWithRegisteredParty {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes::<D>(bytes).map_err(|e| e.into())
         }
     }
 
-    impl TryToBytes for StmAggrSig<D> {
+    impl TryToBytes for AggregateSignature<D> {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for StmAggrSig<D> {
+    impl TryFromBytes for AggregateSignature<D> {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes(bytes).map_err(|e| anyhow!("{e}"))
         }
     }
 
-    impl TryToBytes for StmVerificationKey {
+    impl TryToBytes for VerificationKey {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for StmVerificationKey {
+    impl TryFromBytes for VerificationKey {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes(bytes).map_err(|e| e.into())
         }
     }
 
-    impl TryToBytes for StmVerificationKeyPoP {
+    impl TryToBytes for VerificationKeyProofOfPossession {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for StmVerificationKeyPoP {
+    impl TryFromBytes for VerificationKeyProofOfPossession {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes(bytes).map_err(|e| e.into())
         }
     }
 
-    impl TryToBytes for StmAggrVerificationKey<D> {
+    impl TryToBytes for AggregateVerificationKey<D> {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             bincode::serde::encode_to_vec(self, bincode::config::standard()).map_err(|e| e.into())
         }
     }
 
-    impl TryFromBytes for StmAggrVerificationKey<D> {
+    impl TryFromBytes for AggregateVerificationKey<D> {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
-            let (res, _) = bincode::serde::decode_from_slice::<StmAggrVerificationKey<D>, _>(
+            let (res, _) = bincode::serde::decode_from_slice::<AggregateVerificationKey<D>, _>(
                 bytes,
                 bincode::config::standard(),
             )
@@ -135,13 +135,13 @@ mod binary_mithril_stm {
         }
     }
 
-    impl TryToBytes for StmInitializer {
+    impl TryToBytes for Initializer {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for StmInitializer {
+    impl TryFromBytes for Initializer {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes(bytes).map_err(|e| e.into())
         }

mithril-common/src/crypto_helper/types/alias.rs

@@ -4,7 +4,7 @@ use crate::crypto_helper::cardano::{
 };
 
 use mithril_stm::{
-    AggregationError, ClosedKeyReg, Index, Stake, StmClerk, StmParameters, StmSigner,
+    AggregationError, Clerk, ClosedKeyRegistration, Index, Parameters, Signer, Stake,
 };
 
 use blake2::{Blake2b, digest::consts::U32};
@@ -24,26 +24,26 @@ pub type ProtocolStake = Stake;
 /// A list of [Party Id][ProtocolPartyId] associated with its [Stake][ProtocolStake].
 pub type ProtocolStakeDistribution = Vec<(ProtocolPartyId, ProtocolStake)>;
 
-/// Alias of [MithrilStm::StmParameters](struct@mithril_stm::StmParameters).
-pub type ProtocolParameters = StmParameters;
+/// Alias of [MithrilStm::Parameters](struct@mithril_stm::Parameters).
+pub type ProtocolParameters = Parameters;
 
 /// Alias of [MithrilStm::Index](type@mithril_stm::Index).
 pub type ProtocolLotteryIndex = Index;
 
-/// Alias of [MithrilStm:StmSigner](struct@mithril_stm::StmSigner).
-pub type ProtocolSigner = StmSigner<D>;
+/// Alias of [MithrilStm:Signer](struct@mithril_stm::Signer).
+pub type ProtocolSigner = Signer<D>;
 
-/// Alias of a wrapper of [MithrilStm:StmInitializer](struct@mithril_stm::StmInitializer).
+/// Alias of a wrapper of [MithrilStm:Initializer](struct@mithril_stm::Initializer).
 pub type ProtocolInitializer = StmInitializerWrapper;
 
-/// Alias of [MithrilStm:StmClerk](struct@mithril_stm::StmClerk).
-pub type ProtocolClerk = StmClerk<D>;
+/// Alias of [MithrilStm:Clerk](struct@mithril_stm::Clerk).
+pub type ProtocolClerk = Clerk<D>;
 
-/// Alias of a wrapper of [MithrilStm:KeyReg](struct@mithril_stm::KeyReg).
+/// Alias of a wrapper of [MithrilStm:KeyRegistration](struct@mithril_stm::KeyRegistration).
 pub type ProtocolKeyRegistration = KeyRegWrapper;
 
-/// Alias of a wrapper of [MithrilStm:ClosedKeyReg](struct@mithril_stm::KeyReg).
-pub type ProtocolClosedKeyRegistration = ClosedKeyReg<D>;
+/// Alias of a wrapper of [MithrilStm:ClosedKeyRegistration](struct@mithril_stm::ClosedKeyRegistration).
+pub type ProtocolClosedKeyRegistration = ClosedKeyRegistration<D>;
 
 // Error alias
 /// Alias of a wrapper of [MithrilCommon:ProtocolRegistrationErrorWrapper](enum@ProtocolRegistrationErrorWrapper).