refactor(sha256): use bitcoin::hashes::sha256 instead of sha2 crate

  Per reviewer feedback on PR #208: bitcoin_hashes::sha256 is already
  available via the bitcoin crate re-export and provides equivalent
  SHA-NI hardware acceleration. Drops the direct sha2 dependency.

  Bench (ubuntu-latest w/ SHA-NI, 1000 tx status hashes):
    rust-crypto     273.8 µs
    sha2             54.2 µs
    bitcoin_hashes   53.9 µs

Author: EddieHouston

Cargo.lock

@@ -50,7 +50,6 @@ prometheus = "0.14"
 rayon = "1.5.0"
 rocksdb = "0.24"
 tikv-jemallocator = "0.6"
-sha2 = "0.10"
 serde = "1.0.118"
 serde_derive = "1.0.118"
 serde_json = "1.0.60"

Cargo.toml

@@ -6,9 +6,8 @@ use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
 use std::time::Instant;
 
-use bitcoin::hashes::sha256d::Hash as Sha256dHash;
+use bitcoin::hashes::{sha256, sha256d::Hash as Sha256dHash, Hash, HashEngine};
 use bitcoin::hex::DisplayHex;
-use sha2::{Digest, Sha256};
 use error_chain::ChainedError;
 use serde_json::{from_str, Value};
 
@@ -75,17 +74,17 @@ fn get_status_hash(txs: Vec<(Txid, Option<BlockId>)>, query: &Query) -> Option<F
     if txs.is_empty() {
         None
     } else {
-        let mut hasher = Sha256::new();
+        let mut engine = sha256::Hash::engine();
         for (txid, blockid) in txs {
             let is_mempool = blockid.is_none();
             let has_unconfirmed_parents = is_mempool
                 .and_then(|| Some(query.has_unconfirmed_parents(&txid)))
                 .unwrap_or(false);
             let height = get_electrum_height(blockid, has_unconfirmed_parents);
             let part = format!("{}:{}:", txid, height);
-            hasher.update(part.as_bytes());
+            engine.input(part.as_bytes());
         }
-        Some(hasher.finalize().into())
+        Some(sha256::Hash::from_engine(engine).to_byte_array())
     }
 }
 
@@ -525,10 +524,10 @@ impl Connection {
     }
 
     fn hash_ip_with_salt(&self, ip: &str) -> String {
-        let mut hasher = Sha256::new();
-        hasher.update(self.salt.as_bytes());
-        hasher.update(ip.as_bytes());
-        format!("{:x}", hasher.finalize())
+        let mut engine = sha256::Hash::engine();
+        engine.input(self.salt.as_bytes());
+        engine.input(ip.as_bytes());
+        format!("{:x}", sha256::Hash::from_engine(engine))
     }
 
     fn log_rpc_event(&self, mut log: Value) {

src/electrum/server.rs

@@ -3,9 +3,9 @@ use crate::errors::*;
 use crate::new_index::ChainQuery;
 use crate::util::FullHash;
 
-use sha2::{Digest, Sha256};
 use rayon::prelude::*;
 
+use bitcoin::hashes::{sha256, Hash};
 use bitcoin::hex::FromHex;
 use std::fs::File;
 use std::io;
@@ -73,7 +73,5 @@ fn address_to_scripthash(addr: &str) -> Result<FullHash> {
 }
 
 pub fn compute_script_hash(data: &[u8]) -> FullHash {
-    let mut hasher = Sha256::new();
-    hasher.update(data);
-    hasher.finalize().into()
+    sha256::Hash::hash(data).to_byte_array()
 }

src/new_index/precache.rs

@@ -1,9 +1,8 @@
-use bitcoin::hashes::sha256d::Hash as Sha256dHash;
+use bitcoin::hashes::{sha256, sha256d::Hash as Sha256dHash, Hash};
 use bitcoin::hex::FromHex;
 #[cfg(not(feature = "liquid"))]
 use bitcoin::merkle_tree::MerkleBlock;
 
-use sha2::{Digest, Sha256};
 use itertools::Itertools;
 use rayon::prelude::*;
 
@@ -1437,9 +1436,7 @@ fn addr_search_filter(prefix: &str) -> Bytes {
 pub type FullHash = [u8; 32]; // serialized SHA256 result
 
 pub fn compute_script_hash(script: &Script) -> FullHash {
-    let mut hasher = Sha256::new();
-    hasher.update(script.as_bytes());
-    hasher.finalize().into()
+    sha256::Hash::hash(script.as_bytes()).to_byte_array()
 }
 
 pub fn parse_hash(hash: &FullHash) -> Sha256dHash {
@@ -1988,9 +1985,7 @@ mod tests {
             0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b,
             0x78, 0x52, 0xb8, 0x55,
         ];
-        let mut hasher = Sha256::new();
-        hasher.update(b"");
-        let result: FullHash = hasher.finalize().into();
+        let result: FullHash = sha256::Hash::hash(b"").to_byte_array();
         assert_eq!(result, expected);
     }
 
@@ -2002,9 +1997,7 @@ mod tests {
             0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61,
             0xf2, 0x00, 0x15, 0xad,
         ];
-        let mut hasher = Sha256::new();
-        hasher.update(b"abc");
-        let result: FullHash = hasher.finalize().into();
+        let result: FullHash = sha256::Hash::hash(b"abc").to_byte_array();
         assert_eq!(result, expected);
     }
 
@@ -2018,9 +2011,7 @@ mod tests {
             "6191c3b590bfcfa0475e877c302da1e323497acf3b42c08d8fa28e364edf018b"
         ).unwrap();
 
-        let mut hasher = Sha256::new();
-        hasher.update(&script_bytes);
-        let hash: FullHash = hasher.finalize().into();
+        let hash: FullHash = sha256::Hash::hash(&script_bytes).to_byte_array();
         assert_eq!(hash, expected.as_slice());
     }
 }