swap order import crate and super

Author: damrobi

mithril-stm/src/membership_commitment/merkle_tree/commitment.rs

@@ -3,9 +3,10 @@ use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 
-use super::{MerkleBatchPath, MerklePath, MerkleTreeError, MerkleTreeLeaf, parent, sibling};
 use crate::StmResult;
 
+use super::{MerkleBatchPath, MerklePath, MerkleTreeError, MerkleTreeLeaf, parent, sibling};
+
 /// `MerkleTree` commitment.
 /// This structure differs from `MerkleTree` in that it does not contain all elements, which are not always necessary.
 /// Instead, it only contains the root of the tree.

mithril-stm/src/membership_commitment/merkle_tree/leaf.rs

@@ -2,10 +2,10 @@ use std::cmp::Ordering;
 
 use serde::{Deserialize, Serialize};
 
-use super::MerkleTreeError;
-
 use crate::{Stake, StmResult, VerificationKey, signature_scheme::BlsVerificationKey};
 
+use super::MerkleTreeError;
+
 /// The values that are committed in the Merkle Tree.
 /// Namely, a verified `VerificationKey` and its corresponding stake.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize, Hash)]

mithril-stm/src/membership_commitment/merkle_tree/path.rs

@@ -2,9 +2,10 @@ use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 
-use super::MerkleTreeError;
 use crate::StmResult;
 
+use super::MerkleTreeError;
+
 /// Path of hashes from root to leaf in a Merkle Tree.
 /// Contains all hashes on the path, and the index of the leaf.
 /// Used to verify that signatures come from eligible signers.

mithril-stm/src/membership_commitment/merkle_tree/tree.rs

@@ -2,11 +2,12 @@ use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 
+use crate::StmResult;
+
 use super::{
     MerkleBatchPath, MerklePath, MerkleTreeBatchCommitment, MerkleTreeCommitment, MerkleTreeError,
     MerkleTreeLeaf, left_child, parent, right_child, sibling,
 };
-use crate::StmResult;
 
 /// Tree of hashes, providing a commitment of data and its ordering.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

mithril-stm/src/protocol/aggregate_signature/basic_verifier.rs

@@ -1,14 +1,15 @@
 use anyhow::{Context, anyhow};
 use std::collections::{BTreeMap, HashMap, HashSet};
 
-use super::AggregationError;
 use crate::{
     Index, Parameters, RegisteredParty, SingleSignature, SingleSignatureWithRegisteredParty, Stake,
     StmResult,
     membership_commitment::MerkleTreeLeaf,
     signature_scheme::{BlsSignature, BlsVerificationKey},
 };
 
+use super::AggregationError;
+
 /// Full node verifier including the list of eligible signers and the total stake of the system.
 pub struct BasicVerifier {
     /// List of registered parties.

mithril-stm/src/protocol/aggregate_signature/clerk.rs

@@ -7,12 +7,13 @@ use anyhow::anyhow;
 #[cfg(feature = "future_snark")]
 use super::AggregationError;
 
-use super::{AggregateSignature, AggregateSignatureType, AggregateVerificationKey};
 use crate::{
     ClosedKeyRegistration, Index, Parameters, Signer, SingleSignature, Stake, StmResult,
     VerificationKey, proof_system::ConcatenationProof,
 };
 
+use super::{AggregateSignature, AggregateSignatureType, AggregateVerificationKey};
+
 /// `Clerk` can verify and aggregate `SingleSignature`s and verify `AggregateSignature`s.
 /// Clerks can only be generated with the registration closed.
 /// This avoids that a Merkle Tree is computed before all parties have registered.

mithril-stm/src/protocol/aggregate_signature/signature.rs

@@ -4,12 +4,13 @@ use anyhow::anyhow;
 use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
-use super::{AggregateSignatureError, AggregateVerificationKey};
 use crate::{
     Parameters, StmError, StmResult, membership_commitment::MerkleBatchPath,
     proof_system::ConcatenationProof,
 };
 
+use super::{AggregateSignatureError, AggregateVerificationKey};
+
 /// The type of STM aggregate signature.
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum AggregateSignatureType {

mithril-stm/src/protocol/participant/initializer.rs

@@ -4,12 +4,13 @@ use digest::FixedOutput;
 use rand_core::{CryptoRng, RngCore};
 use serde::{Deserialize, Serialize};
 
-use super::Signer;
 use crate::{
     ClosedKeyRegistration, Parameters, RegisterError, RegisteredParty, Stake, StmResult,
     signature_scheme::{BlsSigningKey, BlsVerificationKeyProofOfPossession},
 };
 
+use super::Signer;
+
 /// Wrapper of the MultiSignature Verification key with proof of possession
 pub type VerificationKeyProofOfPossession = BlsVerificationKeyProofOfPossession;
 

mithril-stm/src/protocol/single_signature/signature.rs

@@ -7,12 +7,13 @@ use anyhow::{Context, anyhow};
 use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
-use super::SignatureError;
 use crate::{
     AggregateVerificationKey, Index, Parameters, Stake, StmResult, VerificationKey, is_lottery_won,
     signature_scheme::BlsSignature,
 };
 
+use super::SignatureError;
+
 /// Signature created by a single party who has won the lottery.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SingleSignature {

mithril-stm/src/protocol/single_signature/signature_registered_party.rs

@@ -1,9 +1,10 @@
 use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize, Serializer, ser::SerializeTuple};
 
-use super::{SignatureError, SingleSignature};
 use crate::{RegisteredParty, StmResult};
 
+use super::{SignatureError, SingleSignature};
+
 /// Signature with its registered party.
 #[derive(Debug, Clone, Hash, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
 pub struct SingleSignatureWithRegisteredParty {