rename: merkle tree

Author: curiecrypt

demo/protocol-demo/src/types.rs

@@ -1,5 +1,5 @@
 use mithril_stm::{
-    Initializer, KeyRegistration, Parameters, Signer, SingleSignature, Stake, StmAggrSig, StmClerk,
+    KeyReg, Stake, StmAggrSig, StmClerk, StmInitializer, StmParameters, StmSig, StmSigner,
     StmVerificationKeyPoP,
 };
 
@@ -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).
-pub type ProtocolParameters = Parameters;
+/// Alias of [MithrilStm::StmParameters](struct@mithril_stm::StmParameters).
+pub type ProtocolParameters = StmParameters;
 
-/// Alias of [MithrilStm:StmSigner](struct@mithril_stm::stm::StmSigner).
-pub type ProtocolSigner = Signer<D>;
+/// 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).
-pub type ProtocolInitializerNotCertified = Initializer;
+/// Alias of [MithrilStm:StmInitializer](struct@mithril_stm::StmInitializer).
+pub type ProtocolInitializerNotCertified = StmInitializer;
 
-/// Alias of [MithrilStm:KeyReg](struct@mithril_stm::key_reg::KeyReg). (Test only)
-pub type ProtocolKeyRegistrationNotCertified = KeyRegistration;
+/// Alias of [MithrilStm:KeyReg](struct@mithril_stm::KeyReg). (Test only)
+pub type ProtocolKeyRegistrationNotCertified = KeyReg;
 
-/// Alias of [MithrilStm:StmSig](struct@mithril_stm::stm::StmSig).
-pub type ProtocolSingleSignature = SingleSignature;
+/// 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-common/src/crypto_helper/cardano/key_certification.rs

@@ -16,7 +16,7 @@ use crate::{
 };
 
 use mithril_stm::{
-    ClosedKeyRegistration, Initializer, KeyRegistration, Parameters, RegisterError, Signer, Stake,
+    ClosedKeyReg, KeyReg, RegisterError, Stake, StmInitializer, StmParameters, StmSigner,
     StmVerificationKeyPoP,
 };
 
@@ -104,7 +104,7 @@ pub enum ProtocolInitializerErrorWrapper {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct StmInitializerWrapper {
     /// The StmInitializer
-    stm_initializer: Initializer,
+    stm_initializer: StmInitializer,
 
     /// The KES signature over the Mithril key
     ///
@@ -120,7 +120,7 @@ pub struct StmInitializerWrapper {
 /// is valid with respect to the PoolID.
 #[derive(Debug, Clone)]
 pub struct KeyRegWrapper {
-    stm_key_reg: KeyRegistration,
+    stm_key_reg: KeyReg,
     stake_distribution: HashMap<ProtocolPartyId, Stake>,
 }
 
@@ -129,13 +129,13 @@ impl StmInitializerWrapper {
     /// This function generates the signing and verification key with a PoP, signs the verification
     /// key with a provided KES signing key, and initializes the structure.
     pub fn setup<R: RngCore + CryptoRng, P: AsRef<Path>>(
-        params: Parameters,
+        params: StmParameters,
         kes_sk_path: Option<P>,
         kes_period: Option<KESPeriod>,
         stake: Stake,
         rng: &mut R,
     ) -> StdResult<Self> {
-        let stm_initializer = Initializer::setup(params, stake, rng);
+        let stm_initializer = StmInitializer::setup(params, stake, rng);
         let kes_signature = if let Some(kes_sk_path) = kes_sk_path {
             let mut kes_sk_bytes = Sum6KesBytes::from_file(kes_sk_path)
                 .map_err(|e| anyhow!(e))
@@ -205,8 +205,8 @@ impl StmInitializerWrapper {
     /// This function fails if the initializer is not registered.
     pub fn new_signer(
         self,
-        closed_reg: ClosedKeyRegistration<D>,
-    ) -> Result<Signer<D>, ProtocolRegistrationErrorWrapper> {
+        closed_reg: ClosedKeyReg<D>,
+    ) -> Result<StmSigner<D>, ProtocolRegistrationErrorWrapper> {
         self.stm_initializer
             .new_signer(closed_reg)
             .map_err(ProtocolRegistrationErrorWrapper::CoreRegister)
@@ -231,7 +231,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 =
-            Initializer::from_bytes(bytes.get(..256).ok_or(RegisterError::SerializationError)?)?;
+            StmInitializer::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
@@ -258,7 +258,7 @@ impl KeyRegWrapper {
     /// but we should eventually transition to only use this one.
     pub fn init(stake_dist: &ProtocolStakeDistribution) -> Self {
         Self {
-            stm_key_reg: KeyRegistration::init(),
+            stm_key_reg: KeyReg::init(),
             stake_distribution: HashMap::from_iter(stake_dist.to_vec()),
         }
     }
@@ -319,7 +319,7 @@ 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) -> ClosedKeyRegistration<D> {
+    pub fn close<D: Digest + FixedOutput>(self) -> ClosedKeyReg<D> {
         self.stm_key_reg.close()
     }
 }
@@ -364,7 +364,7 @@ mod test {
 
     #[test]
     fn test_vector_key_reg() {
-        let params = Parameters {
+        let params = StmParameters {
             m: 5,
             k: 5,
             phi_f: 1.0,

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

@@ -37,45 +37,45 @@ mod binary_mithril_stm {
 
     use digest::consts::U32;
     use mithril_stm::{
-        Initializer, Parameters, SingleSignature, SingleSignatureWithRegisteredParty, StmAggrSig,
-        StmAggrVerificationKey, StmVerificationKey, StmVerificationKeyPoP,
+        StmAggrSig, StmAggrVerificationKey, StmInitializer, StmParameters, StmSig, StmSigRegParty,
+        StmVerificationKey, StmVerificationKeyPoP,
     };
 
     use super::*;
 
     type D = Blake2b<U32>;
 
-    impl TryToBytes for Parameters {
+    impl TryToBytes for StmParameters {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for Parameters {
+    impl TryFromBytes for StmParameters {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes(bytes).map_err(|e| e.into())
         }
     }
 
-    impl TryToBytes for SingleSignature {
+    impl TryToBytes for StmSig {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for SingleSignature {
+    impl TryFromBytes for StmSig {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes::<D>(bytes).map_err(|e| e.into())
         }
     }
 
-    impl TryToBytes for SingleSignatureWithRegisteredParty {
+    impl TryToBytes for StmSigRegParty {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for SingleSignatureWithRegisteredParty {
+    impl TryFromBytes for StmSigRegParty {
         fn try_from_bytes(bytes: &[u8]) -> StdResult<Self> {
             Self::from_bytes::<D>(bytes).map_err(|e| e.into())
         }
@@ -135,13 +135,13 @@ mod binary_mithril_stm {
         }
     }
 
-    impl TryToBytes for Initializer {
+    impl TryToBytes for StmInitializer {
         fn to_bytes_vec(&self) -> StdResult<Vec<u8>> {
             Ok(self.to_bytes().to_vec())
         }
     }
 
-    impl TryFromBytes for Initializer {
+    impl TryFromBytes for StmInitializer {
         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, ClosedKeyRegistration, Index, Parameters, Signer, Stake, StmClerk,
+    AggregationError, ClosedKeyReg, Index, Stake, StmClerk, StmParameters, StmSigner,
 };
 
 use blake2::{digest::consts::U32, Blake2b};
@@ -25,13 +25,13 @@ pub type ProtocolStake = Stake;
 pub type ProtocolStakeDistribution = Vec<(ProtocolPartyId, ProtocolStake)>;
 
 /// Alias of [MithrilStm::StmParameters](struct@mithril_stm::StmParameters).
-pub type ProtocolParameters = Parameters;
+pub type ProtocolParameters = StmParameters;
 
 /// Alias of [MithrilStm::Index](type@mithril_stm::Index).
 pub type ProtocolLotteryIndex = Index;
 
 /// Alias of [MithrilStm:StmSigner](struct@mithril_stm::StmSigner).
-pub type ProtocolSigner = Signer<D>;
+pub type ProtocolSigner = StmSigner<D>;
 
 /// Alias of a wrapper of [MithrilStm:StmInitializer](struct@mithril_stm::StmInitializer).
 pub type ProtocolInitializer = StmInitializerWrapper;
@@ -43,7 +43,7 @@ pub type ProtocolClerk = StmClerk<D>;
 pub type ProtocolKeyRegistration = KeyRegWrapper;
 
 /// Alias of a wrapper of [MithrilStm:ClosedKeyReg](struct@mithril_stm::KeyReg).
-pub type ProtocolClosedKeyRegistration = ClosedKeyRegistration<D>;
+pub type ProtocolClosedKeyRegistration = ClosedKeyReg<D>;
 
 // Error alias
 /// Alias of a wrapper of [MithrilCommon:ProtocolRegistrationErrorWrapper](enum@ProtocolRegistrationErrorWrapper).

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

@@ -1,5 +1,5 @@
 use kes_summed_ed25519::kes::Sum6KesSig;
-use mithril_stm::{SingleSignature, StmAggrSig, StmAggrVerificationKey, StmVerificationKeyPoP};
+use mithril_stm::{StmAggrSig, StmAggrVerificationKey, StmSig, StmVerificationKeyPoP};
 
 use crate::crypto_helper::{MKMapProof, MKProof, OpCert, ProtocolKey, D};
 use crate::entities::BlockRange;
@@ -12,8 +12,8 @@ pub type ProtocolSignerVerificationKey = ProtocolKey<StmVerificationKeyPoP>;
 /// serialization utilities.
 pub type ProtocolSignerVerificationKeySignature = ProtocolKey<Sum6KesSig>;
 
-/// Wrapper of [MithrilStm:SingleSignature](type@SingleSignature) to add serialization utilities.
-pub type ProtocolSingleSignature = ProtocolKey<SingleSignature>;
+/// Wrapper of [MithrilStm:StmSig](type@StmSig) to add serialization utilities.
+pub type ProtocolSingleSignature = ProtocolKey<StmSig>;
 
 /// Wrapper of [MithrilStm:StmAggrSig](struct@StmAggrSig) to add serialization utilities.
 pub type ProtocolMultiSignature = ProtocolKey<StmAggrSig<D>>;
@@ -33,5 +33,5 @@ impl_codec_and_type_conversions_for_protocol_key!(
 );
 
 impl_codec_and_type_conversions_for_protocol_key!(
-    bytes_hex_codec => SingleSignature, ed25519_dalek::Signature
+    bytes_hex_codec => StmSig, ed25519_dalek::Signature
 );

mithril-common/src/entities/single_signature.rs

@@ -1,4 +1,4 @@
-use mithril_stm::SingleSignature as StmSingleSignature;
+use mithril_stm::StmSig;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Debug, Formatter};
 
@@ -52,7 +52,7 @@ impl SingleSignature {
     }
 
     /// Convert this [SingleSignature] to its corresponding [MithrilStm Signature][StmSig].
-    pub fn to_protocol_signature(&self) -> StmSingleSignature {
+    pub fn to_protocol_signature(&self) -> StmSig {
         self.signature.clone().into()
     }
 

mithril-common/src/protocol/multi_signer.rs

@@ -1,5 +1,5 @@
 use anyhow::{anyhow, Context};
-use mithril_stm::Parameters;
+use mithril_stm::StmParameters;
 
 use crate::{
     crypto_helper::{
@@ -14,11 +14,11 @@ use crate::{
 /// MultiSigner is the cryptographic engine in charge of producing multi-signatures from individual signatures
 pub struct MultiSigner {
     protocol_clerk: ProtocolClerk,
-    protocol_parameters: Parameters,
+    protocol_parameters: StmParameters,
 }
 
 impl MultiSigner {
-    pub(super) fn new(protocol_clerk: ProtocolClerk, protocol_parameters: Parameters) -> Self {
+    pub(super) fn new(protocol_clerk: ProtocolClerk, protocol_parameters: StmParameters) -> Self {
         Self {
             protocol_clerk,
             protocol_parameters,

mithril-common/src/test_utils/fake_keys.rs

@@ -392,7 +392,7 @@ mod test {
     use super::*;
     use ed25519_dalek::VerifyingKey;
     use kes_summed_ed25519::kes::Sum6KesSig;
-    use mithril_stm::{StmAggrSig, StmAggrVerificationKey, SingleSignature, StmVerificationKeyPoP};
+    use mithril_stm::{StmAggrSig, StmAggrVerificationKey, StmSig, StmVerificationKeyPoP};
     use serde::{de::DeserializeOwned, Serialize};
     use std::any::type_name;
 
@@ -452,9 +452,9 @@ mod test {
 
     #[test]
     fn assert_encoded_single_signatures_are_still_matching_concrete_type() {
-        assert_can_deserialize_using_key_decode_hex::<SingleSignature>(&single_signature());
+        assert_can_deserialize_using_key_decode_hex::<StmSig>(&single_signature());
 
-        assert_can_convert_to_protocol_key::<SingleSignature>(&single_signature());
+        assert_can_convert_to_protocol_key::<StmSig>(&single_signature());
     }
 
     #[test]

mithril-stm/src/aggregate_signature/aggregate_key.rs

@@ -1,23 +1,23 @@
 use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
-use crate::merkle_tree::{BatchPath, MerkleTreeCommitmentBatchCompat};
+use crate::merkle_tree::{MerkleBatchPath, MerkleTreeBatchCommitment};
 use crate::{ClosedKeyRegistration, Stake};
 
 /// Stm aggregate key (batch compatible), which contains the merkle tree commitment and the total stake of the system.
 /// Batch Compat Merkle tree commitment includes the number of leaves in the tree in order to obtain batch path.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(bound(
-    serialize = "BatchPath<D>: Serialize",
-    deserialize = "BatchPath<D>: Deserialize<'de>"
+    serialize = "MerkleBatchPath<D>: Serialize",
+    deserialize = "MerkleBatchPath<D>: Deserialize<'de>"
 ))]
 pub struct StmAggrVerificationKey<D: Clone + Digest + FixedOutput> {
-    mt_commitment: MerkleTreeCommitmentBatchCompat<D>,
+    mt_commitment: MerkleTreeBatchCommitment<D>,
     total_stake: Stake,
 }
 
 impl<D: Digest + Clone + FixedOutput> StmAggrVerificationKey<D> {
-    pub fn get_mt_commitment(&self) -> MerkleTreeCommitmentBatchCompat<D> {
+    pub fn get_mt_commitment(&self) -> MerkleTreeBatchCommitment<D> {
         self.mt_commitment.clone()
     }
 

mithril-stm/src/aggregate_signature/core_verifier.rs

@@ -2,7 +2,7 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 
 use crate::bls_multi_signature::{Signature, VerificationKey};
 use crate::key_reg::RegisteredParty;
-use crate::merkle_tree::MTLeaf;
+use crate::merkle_tree::MerkleTreeLeaf;
 use crate::{
     AggregationError, CoreVerifierError, Index, Parameters, SingleSignature,
     SingleSignatureWithRegisteredParty, Stake,
@@ -30,7 +30,7 @@ impl CoreVerifier {
                 panic!("Total stake overflow");
             }
             total_stake = res;
-            unique_parties.insert(MTLeaf(signer.0, signer.1));
+            unique_parties.insert(MerkleTreeLeaf(signer.0, signer.1));
         }
 
         let mut eligible_parties: Vec<_> = unique_parties.into_iter().collect();