hashes: reformat

Essentially this just adds indentation after the previous commit.

hashes/src/hash160/mod.rs

@@ -15,17 +15,16 @@ crate::internal_macros::general_hash_type! {
     "Output of the Bitcoin HASH160 hash function. (RIPEMD160(SHA256))"
 }
 
-
 impl Hash {
-/// Finalize a hash engine to produce a hash.
-pub fn from_engine(e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    pub fn from_engine(e: HashEngine) -> Self {
         let sha2 = sha256::Hash::from_engine(e.0);
         let rmd = ripemd160::Hash::hash(sha2.as_byte_array());
 
         let mut ret = [0; 20];
         ret.copy_from_slice(rmd.as_byte_array());
         Hash(ret)
-}
+    }
 }
 
 /// Engine to compute HASH160 hash function.

hashes/src/ripemd160/mod.rs

@@ -20,11 +20,10 @@ crate::internal_macros::general_hash_type! {
     "Output of the RIPEMD160 hash function."
 }
 
-
 impl Hash {
-/// Finalize a hash engine to produce a hash.
-#[cfg(not(hashes_fuzz))]
-pub fn from_engine(mut e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    #[cfg(not(hashes_fuzz))]
+    pub fn from_engine(mut e: HashEngine) -> Self {
         // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
         let n_bytes_hashed = e.bytes_hashed;
 
@@ -41,15 +40,15 @@ pub fn from_engine(mut e: HashEngine) -> Self {
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
         Hash(e.midstate())
-}
+    }
 
-/// Finalize a hash engine to produce a hash.
-#[cfg(hashes_fuzz)]
-pub fn from_engine(e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    #[cfg(hashes_fuzz)]
+    pub fn from_engine(e: HashEngine) -> Self {
         let mut res = e.midstate();
         res[0] ^= (e.bytes_hashed & 0xff) as u8;
         Hash(res)
-}
+    }
 }
 
 const BLOCK_SIZE: usize = 64;

hashes/src/sha1/mod.rs

@@ -21,8 +21,8 @@ crate::internal_macros::general_hash_type! {
 }
 
 impl Hash {
-/// Finalize a hash engine to produce a hash.
-pub fn from_engine(mut e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    pub fn from_engine(mut e: HashEngine) -> Self {
         // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
         let n_bytes_hashed = e.bytes_hashed;
 
@@ -39,7 +39,7 @@ pub fn from_engine(mut e: HashEngine) -> Self {
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
         Hash(e.midstate())
-}
+    }
 }
 
 const BLOCK_SIZE: usize = 64;

hashes/src/sha256/mod.rs

@@ -110,9 +110,9 @@ impl crate::HashEngine for HashEngine {
 }
 
 impl Hash {
-/// Finalize a hash engine to obtain a hash.
-#[cfg(not(hashes_fuzz))]
-pub fn from_engine(mut e: HashEngine) -> Self {
+    /// Finalize a hash engine to obtain a hash.
+    #[cfg(not(hashes_fuzz))]
+    pub fn from_engine(mut e: HashEngine) -> Self {
         // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
         let n_bytes_hashed = e.bytes_hashed;
 
@@ -129,11 +129,11 @@ pub fn from_engine(mut e: HashEngine) -> Self {
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
         Hash(e.midstate_unchecked().bytes)
-}
+    }
 
-/// Finalize a hash engine to obtain a hash.
-#[cfg(hashes_fuzz)]
-pub fn from_engine(e: HashEngine) -> Self {
+    /// Finalize a hash engine to obtain a hash.
+    #[cfg(hashes_fuzz)]
+    pub fn from_engine(e: HashEngine) -> Self {
         let mut hash = e.midstate_unchecked().bytes;
         if hash == [0; 32] {
             // Assume sha256 is secure and never generate 0-hashes (which represent invalid
@@ -141,7 +141,7 @@ pub fn from_engine(e: HashEngine) -> Self {
             hash[0] = 1;
         }
         Hash(hash)
-}
+    }
 
     /// Iterate the sha256 algorithm to turn a sha256 hash into a sha256d hash
     #[must_use]

hashes/src/sha256d/mod.rs

@@ -11,15 +11,15 @@ crate::internal_macros::general_hash_type! {
 }
 
 impl Hash {
-/// Finalize a hash engine to produce a hash.
-pub fn from_engine(e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    pub fn from_engine(e: HashEngine) -> Self {
         let sha2 = sha256::Hash::from_engine(e.0);
         let sha2d = sha256::Hash::hash(sha2.as_byte_array());
 
         let mut ret = [0; 32];
         ret.copy_from_slice(sha2d.as_byte_array());
         Hash(ret)
-}
+    }
 }
 
 /// Engine to compute SHA256d hash function.

hashes/src/sha384/mod.rs

@@ -11,12 +11,12 @@ crate::internal_macros::general_hash_type! {
 }
 
 impl Hash {
-/// Finalize a hash engine to produce a hash.
-pub fn from_engine(e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    pub fn from_engine(e: HashEngine) -> Self {
         let mut ret = [0; 48];
         ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..48]);
         Hash(ret)
-}
+    }
 }
 
 /// Engine to compute SHA384 hash function.

hashes/src/sha512/mod.rs

@@ -21,9 +21,9 @@ crate::internal_macros::general_hash_type! {
 }
 
 impl Hash {
-/// Finalize a hash engine to produce a hash.
-#[cfg(not(hashes_fuzz))]
-pub fn from_engine(mut e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    #[cfg(not(hashes_fuzz))]
+    pub fn from_engine(mut e: HashEngine) -> Self {
         // pad buffer with a single 1-bit then all 0s, until there are exactly 16 bytes remaining
         let n_bytes_hashed = e.bytes_hashed;
 
@@ -41,15 +41,15 @@ pub fn from_engine(mut e: HashEngine) -> Self {
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
         Hash(e.midstate())
-}
+    }
 
-/// Finalize a hash engine to produce a hash.
-#[cfg(hashes_fuzz)]
-pub fn from_engine(e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    #[cfg(hashes_fuzz)]
+    pub fn from_engine(e: HashEngine) -> Self {
         let mut hash = e.midstate();
         hash[0] ^= 0xff; // Make this distinct from SHA-256
         Hash(hash)
-}
+    }
 }
 
 pub(crate) const BLOCK_SIZE: usize = 128;

hashes/src/sha512_256/mod.rs

@@ -16,12 +16,12 @@ crate::internal_macros::general_hash_type! {
 }
 
 impl Hash {
-/// Finalize a hash engine to produce a hash.
-pub fn from_engine(e: HashEngine) -> Self {
+    /// Finalize a hash engine to produce a hash.
+    pub fn from_engine(e: HashEngine) -> Self {
         let mut ret = [0; 32];
         ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..32]);
         Hash(ret)
-}
+    }
 }
 
 /// Engine to compute SHA512/256 hash function.