use bitcoin_hashes 1.0 throughout the codebase

This is a fairly big commit but it's mostly mechanical and it didn't seem
super helpful to pull it out into multiple commits. The bulk of the
prepatory work was done in #278.

Author: apoelstra

Cargo.toml

@@ -191,6 +191,7 @@ zero_sized_map_values = "warn"
 
 [package.metadata.rbmt.lint]
 allowed_duplicates = [
+    "bitcoin_hashes",
     "bitcoin-internals",
     "hex-conservative",
 ]

elementsd-tests/Cargo.toml

@@ -16,6 +16,7 @@ rand = "0.8"
 [package.metadata.rbmt.lint]
 # FIXME the bulk of these are because elementsd/bitcoind is much older than rust-bitcoin.
 allowed_duplicates = [
+    "bitcoin_hashes",
     "bitcoin-internals",
     "hex-conservative",
     "base64",

elementsd-tests/src/pset.rs

@@ -8,7 +8,6 @@ use crate::{setup, Call};
 
 use bitcoin::{self, Address, Amount};
 use elements::encode::serialize;
-use elements::hashes::Hash;
 use elements::hex::DisplayHex as _;
 use elements::pset::PartiallySignedTransaction;
 use elements::{AssetId, ContractHash};

elementsd-tests/src/taproot.rs

@@ -10,7 +10,6 @@ use bitcoin::Amount;
 use elements::hex;
 use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
 use elements::encode::{deserialize, serialize_hex};
-use elements::hashes::Hash;
 use elements::script::Builder;
 use elements::secp256k1_zkp;
 use elements::sighash::{self, SighashCache};
@@ -215,7 +214,7 @@ fn taproot_spend_test(
         );
         let tweak = secp256k1_zkp::Scalar::from_be_bytes(tweak.to_byte_array()).expect("hash value greater than curve order");
         let sig = secp.sign_schnorr(
-            &secp256k1_zkp::Message::from_digest_slice(&sighash_msg[..]).unwrap(),
+            &secp256k1_zkp::Message::from_digest(sighash_msg.to_byte_array()),
             &output_keypair.add_xonly_tweak(secp, &tweak).unwrap(),
         );
 
@@ -239,7 +238,7 @@ fn taproot_spend_test(
             .unwrap();
 
         let sig = secp.sign_schnorr(
-            &secp256k1_zkp::Message::from_digest_slice(&sighash_msg[..]).unwrap(),
+            &secp256k1_zkp::Message::from_digest(sighash_msg.to_byte_array()),
             &test_data.leaf1_keypair,
         );
 

fuzz/Cargo.toml

@@ -26,6 +26,7 @@ use_self = "warn"
 
 [package.metadata.rbmt.lint]
 allowed_duplicates = [
+    "bitcoin_hashes",
     "bitcoin-internals",
     "hex-conservative",
     "getrandom",

src/address.rs

@@ -15,16 +15,16 @@
 //! # Addresses
 //!
 
-use std::convert::TryFrom as _;
+use std::convert::{TryFrom as _, TryInto as _};
 use std::error;
 use std::fmt;
 use std::fmt::Write as _;
 use std::str::FromStr;
 
 use bech32::{Bech32, Bech32m, ByteIterExt, Fe32, Fe32IterExt, Hrp};
 use crate::blech32::{Blech32, Blech32m};
-use crate::hashes::Hash;
 use bitcoin::base58;
+use bitcoin::hashes::Hash as _;
 use bitcoin::PublicKey;
 use internals::array::ArrayExt as _;
 use internals::slice::SliceExt;
@@ -329,12 +329,12 @@ impl Address {
     ) -> Address {
         let ws = script::Builder::new()
             .push_int(0)
-            .push_slice(&WScriptHash::hash(&script[..])[..])
+            .push_slice(WScriptHash::hash_script(script).as_ref())
             .into_script();
 
         Address {
             params,
-            payload: Payload::ScriptHash(ScriptHash::hash(&ws[..])),
+            payload: Payload::ScriptHash(ScriptHash::hash_script(&ws)),
             blinding_pubkey: blinder,
         }
     }
@@ -386,9 +386,9 @@ impl Address {
     ) -> Option<Address> {
         Some(Address {
             payload: if script.is_p2pkh() {
-                Payload::PubkeyHash(Hash::from_slice(&script.as_bytes()[3..23]).unwrap())
+                Payload::PubkeyHash(PubkeyHash::from_byte_array(script.as_bytes()[3..23].try_into().unwrap()))
             } else if script.is_p2sh() {
-                Payload::ScriptHash(Hash::from_slice(&script.as_bytes()[2..22]).unwrap())
+                Payload::ScriptHash(ScriptHash::from_byte_array(script.as_bytes()[2..22].try_into().unwrap()))
             } else if script.is_v0_p2wpkh() {
                 Payload::WitnessProgram {
                     version: Fe32::Q,
@@ -418,12 +418,12 @@ impl Address {
             Payload::PubkeyHash(ref hash) => script::Builder::new()
                 .push_opcode(opcodes::all::OP_DUP)
                 .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&hash[..])
+                .push_slice(hash.as_ref())
                 .push_opcode(opcodes::all::OP_EQUALVERIFY)
                 .push_opcode(opcodes::all::OP_CHECKSIG),
             Payload::ScriptHash(ref hash) => script::Builder::new()
                 .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&hash[..])
+                .push_slice(hash.as_byte_array())
                 .push_opcode(opcodes::all::OP_EQUAL),
             Payload::WitnessProgram {
                 version: witver,
@@ -566,12 +566,12 @@ impl fmt::Display for Address {
                     prefixed[0] = self.params.blinded_prefix;
                     prefixed[1] = self.params.p2pkh_prefix;
                     prefixed[2..35].copy_from_slice(&blinder.serialize());
-                    prefixed[35..].copy_from_slice(&hash[..]);
+                    prefixed[35..].copy_from_slice(hash.as_ref());
                     base58::encode_check_to_fmt(fmt, &prefixed[..])
                 } else {
                     let mut prefixed = [0; 21];
                     prefixed[0] = self.params.p2pkh_prefix;
-                    prefixed[1..].copy_from_slice(&hash[..]);
+                    prefixed[1..].copy_from_slice(hash.as_ref());
                     base58::encode_check_to_fmt(fmt, &prefixed[..])
                 }
             }
@@ -581,12 +581,12 @@ impl fmt::Display for Address {
                     prefixed[0] = self.params.blinded_prefix;
                     prefixed[1] = self.params.p2sh_prefix;
                     prefixed[2..35].copy_from_slice(&blinder.serialize());
-                    prefixed[35..].copy_from_slice(&hash[..]);
+                    prefixed[35..].copy_from_slice(hash.as_byte_array());
                     base58::encode_check_to_fmt(fmt, &prefixed[..])
                 } else {
                     let mut prefixed = [0; 21];
                     prefixed[0] = self.params.p2sh_prefix;
-                    prefixed[1..].copy_from_slice(&hash[..]);
+                    prefixed[1..].copy_from_slice(hash.as_byte_array());
                     base58::encode_check_to_fmt(fmt, &prefixed[..])
                 }
             }
@@ -937,7 +937,7 @@ mod test {
             "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51",
         )
         .unwrap();
-        let tap_node_hash = TapNodeHash::all_zeros();
+        let tap_node_hash = TapNodeHash::from_byte_array([0; 32]);
 
         let mut expected = IntoIterator::into_iter([
             "2dszRCFv8Ub4ytKo1Q1vXXGgSx7mekNDwSJ",

src/block.rs

@@ -21,7 +21,7 @@ use std::io;
 #[cfg(feature = "serde")] use std::fmt;
 
 use crate::dynafed;
-use crate::hashes::Hash;
+use crate::hashes::{HashEngine as _, sha256d};
 use crate::Transaction;
 use crate::encode::{self, serialize, Decodable, Encodable, VarInt};
 use crate::{BlockHash, Script, TxMerkleNode};
@@ -235,7 +235,7 @@ impl BlockHeader {
         };
 
         // Everything except the signblock witness goes into the hash
-        let mut enc = BlockHash::engine();
+        let mut enc = sha256d::Hash::engine();
         version.consensus_encode(&mut enc).unwrap();
         self.prev_blockhash.consensus_encode(&mut enc).unwrap();
         self.merkle_root.consensus_encode(&mut enc).unwrap();
@@ -250,7 +250,7 @@ impl BlockHeader {
                 proposed.consensus_encode(&mut enc).unwrap();
             },
         }
-        BlockHash::from_engine(enc)
+        BlockHash(enc.finalize())
     }
 
     /// Returns true if this is a block with dynamic federations enabled.

src/confidential.rs

@@ -17,7 +17,7 @@
 //! Structures representing Pedersen commitments of various types
 //!
 
-use crate::hashes::{sha256d, Hash};
+use crate::hashes::sha256d;
 use secp256k1_zkp::{self, CommitmentSecrets, Generator, PedersenCommitment,
     PublicKey, Secp256k1, SecretKey, Signing, Tweak, ZERO_TWEAK,
     compute_adaptive_blinding_factor,

src/dynafed.rs

@@ -23,7 +23,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::ser::{SerializeSeq, SerializeStruct};
 
 use crate::encode::{self, Encodable, Decodable};
-use crate::hashes::{Hash, sha256d};
+use crate::hashes::sha256d;
 use crate::Script;
 
 impl_sha256_midstate_wrapper! {
@@ -149,7 +149,7 @@ impl FullParams {
         let compact_root = crate::fast_merkle_root::fast_merkle_root(&leaves[..]);
 
         let leaves = [
-            compact_root.to_byte_array(),
+            compact_root.to_parts().0,
             self.extra_root().to_byte_array(),
         ];
         ParamsRoot::from_midstate(crate::fast_merkle_root::fast_merkle_root(&leaves[..]))
@@ -364,7 +364,7 @@ impl Params {
             serialize_hash(self.signblockscript().unwrap()).to_byte_array(),
             serialize_hash(&self.signblock_witness_limit().unwrap()).to_byte_array(),
         ];
-        let compact_root = crate::fast_merkle_root::fast_merkle_root(&leaves[..]);
+        let compact_root = ElidedRoot::from_midstate(crate::fast_merkle_root::fast_merkle_root(&leaves[..]));
 
         let leaves = [
             compact_root.to_byte_array(),
@@ -718,8 +718,8 @@ mod tests {
                 signblock_witness: vec![],
             },
             version: Default::default(),
-            prev_blockhash: BlockHash::all_zeros(),
-            merkle_root: TxMerkleNode::all_zeros(),
+            prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
+            merkle_root: TxMerkleNode::from_byte_array([0; 32]),
             time: Default::default(),
             height: Default::default(),
         };

src/encode.rs

@@ -298,16 +298,14 @@ impl Decodable for bitcoin::ScriptBuf {
     }
 }
 
-impl Encodable for bitcoin::hashes::sha256d::Hash {
+impl Encodable for hashes::sha256d::Hash {
     fn consensus_encode<W: io::Write>(&self, mut w: W) -> Result<usize, Error> {
         self.as_byte_array().consensus_encode(&mut w)
     }
 }
-impl Decodable for bitcoin::hashes::sha256d::Hash {
+impl Decodable for hashes::sha256d::Hash {
     fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(Self::from_byte_array(
-            <<Self as Hash>::Bytes>::consensus_decode(d)?,
-        ))
+        Ok(Self::from_byte_array(<[u8; 32]>::consensus_decode(d)?))
     }
 }