hkd32: Run rustfmt on imported bip39 code

tony-iqlusion · tony-iqlusion · commit ff4880a70979 · 2019-08-20T06:21:58.000-07:00
Applies rustfmt with no other changes, using the following version:

    rustfmt 1.2.2-stable (5274b49c 2019-04-24)
diff --git a/hkd32/LICENSE-MIT b/hkd32/LICENSE-MIT
@@ -1,5 +1,7 @@
 The MIT License (MIT)
+
 Copyright (c) 2017-2018 Stephen Oliver
+Copyright (c) 2019 iqlusion
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/hkd32/src/mnemonic/crypto.rs b/hkd32/src/mnemonic/crypto.rs
@@ -6,9 +6,9 @@
 //!
 
 extern crate rand;
-use self::rand::{ thread_rng, RngCore };
-use sha2::Digest;
+use self::rand::{thread_rng, RngCore};
 use hmac::Hmac;
+use sha2::Digest;
 
 const PBKDF2_ROUNDS: usize = 2048;
 const PBKDF2_BYTES: usize = 64;
diff --git a/hkd32/src/mnemonic/error.rs b/hkd32/src/mnemonic/error.rs
@@ -2,14 +2,17 @@ use mnemonic_type::MnemonicType;
 
 #[derive(Debug, Fail)]
 pub enum ErrorKind {
-	#[fail(display = "invalid checksum")]
-	InvalidChecksum,
-	#[fail(display = "invalid word in phrase")]
-	InvalidWord,
-	#[fail(display = "invalid keysize: {}", _0)]
-	InvalidKeysize(usize),
-	#[fail(display = "invalid number of words in phrase: {}", _0)]
-	InvalidWordLength(usize),
-	#[fail(display = "invalid entropy length {}bits for mnemonic type {:?}", _0, _1)]
-	InvalidEntropyLength(usize, MnemonicType),
-}
+    #[fail(display = "invalid checksum")]
+    InvalidChecksum,
+    #[fail(display = "invalid word in phrase")]
+    InvalidWord,
+    #[fail(display = "invalid keysize: {}", _0)]
+    InvalidKeysize(usize),
+    #[fail(display = "invalid number of words in phrase: {}", _0)]
+    InvalidWordLength(usize),
+    #[fail(
+        display = "invalid entropy length {}bits for mnemonic type {:?}",
+        _0, _1
+    )]
+    InvalidEntropyLength(usize, MnemonicType),
+}
diff --git a/hkd32/src/mnemonic/language.rs b/hkd32/src/mnemonic/language.rs
@@ -1,22 +1,21 @@
-use hashbrown::HashMap;
 use error::ErrorKind;
 use failure::Error;
-use util::{Bits11, Bits};
+use hashbrown::HashMap;
+use util::{Bits, Bits11};
 
 pub struct WordMap {
-    inner: HashMap<&'static str, Bits11>
-
+    inner: HashMap<&'static str, Bits11>,
 }
 
 pub struct WordList {
-    inner: Vec<&'static str>
+    inner: Vec<&'static str>,
 }
 
 impl WordMap {
     pub fn get_bits(&self, word: &str) -> Result<Bits11, Error> {
         match self.inner.get(word) {
             Some(n) => Ok(*n),
-            None => Err(ErrorKind::InvalidWord)?
+            None => Err(ErrorKind::InvalidWord)?,
         }
     }
 }
@@ -37,55 +36,62 @@ mod lazy {
 
         debug_assert!(inner.len() == 2048, "Invalid wordlist length");
 
-        WordList {
-            inner
-        }
+        WordList { inner }
     }
 
     /// lazy generation of the word map
     fn gen_wordmap(wordlist: &WordList) -> WordMap {
-        let inner = wordlist.inner
-                            .iter()
-                            .enumerate()
-                            .map(|(i, item)| (*item, Bits11::from(i as u16)))
-                            .collect();
-
-        WordMap {
-            inner
-        }
+        let inner = wordlist
+            .inner
+            .iter()
+            .enumerate()
+            .map(|(i, item)| (*item, Bits11::from(i as u16)))
+            .collect();
+
+        WordMap { inner }
     }
 
-    pub static WORDLIST_ENGLISH: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/english.txt")) };
+    pub static WORDLIST_ENGLISH: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/english.txt")) };
     #[cfg(feature = "chinese-simplified")]
-    pub static WORDLIST_CHINESE_SIMPLIFIED: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/chinese_simplified.txt")) };
+    pub static WORDLIST_CHINESE_SIMPLIFIED: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/chinese_simplified.txt")) };
     #[cfg(feature = "chinese-traditional")]
-    pub static WORDLIST_CHINESE_TRADITIONAL: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/chinese_traditional.txt")) };
+    pub static WORDLIST_CHINESE_TRADITIONAL: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/chinese_traditional.txt")) };
     #[cfg(feature = "french")]
-    pub static WORDLIST_FRENCH: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/french.txt")) };
+    pub static WORDLIST_FRENCH: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/french.txt")) };
     #[cfg(feature = "italian")]
-    pub static WORDLIST_ITALIAN: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/italian.txt")) };
+    pub static WORDLIST_ITALIAN: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/italian.txt")) };
     #[cfg(feature = "japanese")]
-    pub static WORDLIST_JAPANESE: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/japanese.txt")) };
+    pub static WORDLIST_JAPANESE: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/japanese.txt")) };
     #[cfg(feature = "korean")]
-    pub static WORDLIST_KOREAN: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/korean.txt")) };
+    pub static WORDLIST_KOREAN: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/korean.txt")) };
     #[cfg(feature = "spanish")]
-    pub static WORDLIST_SPANISH: Lazy<WordList> = sync_lazy!{ gen_wordlist(include_str!("langs/spanish.txt")) };
+    pub static WORDLIST_SPANISH: Lazy<WordList> =
+        sync_lazy! { gen_wordlist(include_str!("langs/spanish.txt")) };
 
-    pub static WORDMAP_ENGLISH: Lazy<WordMap> = sync_lazy!{ gen_wordmap(&WORDLIST_ENGLISH) };
+    pub static WORDMAP_ENGLISH: Lazy<WordMap> = sync_lazy! { gen_wordmap(&WORDLIST_ENGLISH) };
     #[cfg(feature = "chinese-simplified")]
-    pub static WORDMAP_CHINESE_SIMPLIFIED: Lazy<WordMap> = sync_lazy!{  gen_wordmap(&WORDLIST_CHINESE_SIMPLIFIED) };
+    pub static WORDMAP_CHINESE_SIMPLIFIED: Lazy<WordMap> =
+        sync_lazy! {  gen_wordmap(&WORDLIST_CHINESE_SIMPLIFIED) };
     #[cfg(feature = "chinese-traditional")]
-    pub static WORDMAP_CHINESE_TRADITIONAL: Lazy<WordMap> = sync_lazy!{ gen_wordmap(&WORDLIST_CHINESE_TRADITIONAL) };
+    pub static WORDMAP_CHINESE_TRADITIONAL: Lazy<WordMap> =
+        sync_lazy! { gen_wordmap(&WORDLIST_CHINESE_TRADITIONAL) };
     #[cfg(feature = "french")]
-    pub static WORDMAP_FRENCH: Lazy<WordMap> = sync_lazy!{ gen_wordmap(&WORDLIST_FRENCH) };
+    pub static WORDMAP_FRENCH: Lazy<WordMap> = sync_lazy! { gen_wordmap(&WORDLIST_FRENCH) };
     #[cfg(feature = "italian")]
-    pub static WORDMAP_ITALIAN: Lazy<WordMap> = sync_lazy!{ gen_wordmap(&WORDLIST_ITALIAN) };
+    pub static WORDMAP_ITALIAN: Lazy<WordMap> = sync_lazy! { gen_wordmap(&WORDLIST_ITALIAN) };
     #[cfg(feature = "japanese")]
-    pub static WORDMAP_JAPANESE: Lazy<WordMap> = sync_lazy!{ gen_wordmap(&WORDLIST_JAPANESE) };
+    pub static WORDMAP_JAPANESE: Lazy<WordMap> = sync_lazy! { gen_wordmap(&WORDLIST_JAPANESE) };
     #[cfg(feature = "korean")]
-    pub static WORDMAP_KOREAN: Lazy<WordMap> = sync_lazy!{ gen_wordmap(&WORDLIST_KOREAN) };
+    pub static WORDMAP_KOREAN: Lazy<WordMap> = sync_lazy! { gen_wordmap(&WORDLIST_KOREAN) };
     #[cfg(feature = "spanish")]
-    pub static WORDMAP_SPANISH: Lazy<WordMap> = sync_lazy!{ gen_wordmap(&WORDLIST_SPANISH) };
+    pub static WORDMAP_SPANISH: Lazy<WordMap> = sync_lazy! { gen_wordmap(&WORDLIST_SPANISH) };
 
 }
 
diff --git a/hkd32/src/mnemonic/lib.rs b/hkd32/src/mnemonic/lib.rs
@@ -27,24 +27,26 @@
 //! println!("{:X}", seed);
 //! ```
 //!
-#[macro_use] extern crate failure;
-#[macro_use] extern crate once_cell;
-extern crate pbkdf2;
+#[macro_use]
+extern crate failure;
+#[macro_use]
+extern crate once_cell;
 extern crate hashbrown;
-extern crate sha2;
 extern crate hmac;
+extern crate pbkdf2;
+extern crate sha2;
 
-mod mnemonic;
 mod error;
-mod mnemonic_type;
 mod language;
-mod util;
+mod mnemonic;
+mod mnemonic_type;
 mod seed;
+mod util;
 
 mod crypto;
 
+pub use error::ErrorKind;
 pub use language::Language;
 pub use mnemonic::Mnemonic;
 pub use mnemonic_type::MnemonicType;
 pub use seed::Seed;
-pub use error::ErrorKind;
diff --git a/hkd32/src/mnemonic/mnemonic.rs b/hkd32/src/mnemonic/mnemonic.rs
@@ -1,10 +1,10 @@
-use util::{checksum, IterExt, BitWriter};
 use crypto::{gen_random_bytes, sha256_first_byte};
 use error::ErrorKind;
 use failure::Error;
-use mnemonic_type::MnemonicType;
 use language::Language;
+use mnemonic_type::MnemonicType;
 use std::fmt;
+use util::{checksum, BitWriter, IterExt};
 
 /// The primary type in this crate, most tasks require creating or using one.
 ///
@@ -86,7 +86,7 @@ impl Mnemonic {
 
     fn from_entropy_unchecked<E>(entropy: E, lang: Language) -> Mnemonic
     where
-        E: Into<Vec<u8>>
+        E: Into<Vec<u8>>,
     {
         let entropy = entropy.into();
         let wordlist = lang.wordlist();
@@ -102,16 +102,17 @@ impl Mnemonic {
         //
         // Given the entropy is of correct size, this ought to give us the correct word
         // count.
-        let phrase = entropy.iter()
-                            .chain(Some(&checksum_byte))
-                            .bits()
-                            .map(|bits| wordlist.get_word(bits))
-                            .join(" ");
+        let phrase = entropy
+            .iter()
+            .chain(Some(&checksum_byte))
+            .bits()
+            .map(|bits| wordlist.get_word(bits))
+            .join(" ");
 
         Mnemonic {
             phrase,
             lang,
-            entropy
+            entropy,
         }
     }
 
@@ -189,7 +190,10 @@ impl Mnemonic {
 
         let mtype = MnemonicType::for_word_count(bits.len() / 11)?;
 
-        debug_assert!(bits.len() == mtype.total_bits(), "Insufficient amount of bits to validate");
+        debug_assert!(
+            bits.len() == mtype.total_bits(),
+            "Insufficient amount of bits to validate"
+        );
 
         let mut entropy = bits.into_bytes();
         let entropy_bytes = mtype.entropy_bits() / 8;
@@ -319,7 +323,10 @@ mod test {
 
     #[test]
     fn mnemonic_from_entropy() {
-        let entropy = &[0x33, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84, 0x6A, 0x79];
+        let entropy = &[
+            0x33, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84,
+            0x6A, 0x79,
+        ];
         let phrase = "crop cash unable insane eight faith inflict route frame loud box vibrant";
 
         let mnemonic = Mnemonic::from_entropy(entropy, Language::English).unwrap();
@@ -329,7 +336,10 @@ mod test {
 
     #[test]
     fn mnemonic_from_phrase() {
-        let entropy = &[0x33, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84, 0x6A, 0x79];
+        let entropy = &[
+            0x33, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84,
+            0x6A, 0x79,
+        ];
         let phrase = "crop cash unable insane eight faith inflict route frame loud box vibrant";
 
         let mnemonic = Mnemonic::from_phrase(phrase, Language::English).unwrap();
@@ -346,13 +356,28 @@ mod test {
 
     #[test]
     fn mnemonic_hex_format() {
-        let entropy = &[0x03, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84, 0x6A, 0x79];
+        let entropy = &[
+            0x03, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84,
+            0x6A, 0x79,
+        ];
 
         let mnemonic = Mnemonic::from_entropy(entropy, Language::English).unwrap();
 
-        assert_eq!(format!("{:x}", mnemonic), "03e46bb13a746ea41cdde45c90846a79");
-        assert_eq!(format!("{:X}", mnemonic), "03E46BB13A746EA41CDDE45C90846A79");
-        assert_eq!(format!("{:#x}", mnemonic), "0x03e46bb13a746ea41cdde45c90846a79");
-        assert_eq!(format!("{:#X}", mnemonic), "0x03E46BB13A746EA41CDDE45C90846A79");
+        assert_eq!(
+            format!("{:x}", mnemonic),
+            "03e46bb13a746ea41cdde45c90846a79"
+        );
+        assert_eq!(
+            format!("{:X}", mnemonic),
+            "03E46BB13A746EA41CDDE45C90846A79"
+        );
+        assert_eq!(
+            format!("{:#x}", mnemonic),
+            "0x03e46bb13a746ea41cdde45c90846a79"
+        );
+        assert_eq!(
+            format!("{:#X}", mnemonic),
+            "0x03E46BB13A746EA41CDDE45C90846A79"
+        );
     }
 }
diff --git a/hkd32/src/mnemonic/mnemonic_type.rs b/hkd32/src/mnemonic/mnemonic_type.rs
@@ -58,7 +58,7 @@ impl MnemonicType {
             18 => MnemonicType::Words18,
             21 => MnemonicType::Words21,
             24 => MnemonicType::Words24,
-            _ => Err(ErrorKind::InvalidWordLength(size))?
+            _ => Err(ErrorKind::InvalidWordLength(size))?,
         };
 
         Ok(mnemonic_type)
@@ -82,7 +82,7 @@ impl MnemonicType {
             192 => MnemonicType::Words18,
             224 => MnemonicType::Words21,
             256 => MnemonicType::Words24,
-            _ => Err(ErrorKind::InvalidKeysize(size))?
+            _ => Err(ErrorKind::InvalidKeysize(size))?,
         };
 
         Ok(mnemonic_type)
@@ -190,7 +190,12 @@ impl Default for MnemonicType {
 
 impl fmt::Display for MnemonicType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} words ({}bits)", self.word_count(), self.entropy_bits())
+        write!(
+            f,
+            "{} words ({}bits)",
+            self.word_count(),
+            self.entropy_bits()
+        )
     }
 }
 
diff --git a/hkd32/src/mnemonic/seed.rs b/hkd32/src/mnemonic/seed.rs
@@ -29,9 +29,7 @@ impl Seed {
         let salt = format!("mnemonic{}", password);
         let bytes = pbkdf2(mnemonic.phrase().as_bytes(), &salt);
 
-        Self {
-            bytes,
-        }
+        Self { bytes }
     }
 
     /// Get the seed value as a byte slice
@@ -87,7 +85,10 @@ mod test {
 
     #[test]
     fn seed_hex_format() {
-        let entropy = &[0x33, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84, 0x6A, 0x79];
+        let entropy = &[
+            0x33, 0xE4, 0x6B, 0xB1, 0x3A, 0x74, 0x6E, 0xA4, 0x1C, 0xDD, 0xE4, 0x5C, 0x90, 0x84,
+            0x6A, 0x79,
+        ];
 
         let mnemonic = Mnemonic::from_entropy(entropy, Language::English).unwrap();
         let seed = Seed::new(&mnemonic, "password");
diff --git a/hkd32/src/mnemonic/util.rs b/hkd32/src/mnemonic/util.rs
diff --git a/hkd32/tests/bip39/generate.rs b/hkd32/tests/bip39/generate.rs
diff --git a/hkd32/tests/bip39/standard-vectors.rs b/hkd32/tests/bip39/standard-vectors.rs
diff --git a/hkd32/tests/bip39/validate.rs b/hkd32/tests/bip39/validate.rs
