re-export WPubkeyHash and PubkeyHash rather than defining our own

We already re-export and use rust-bitcoin's PublicKey type. The two hashes of
keys that are used in Script are identical in Bitcoin and Elements, and have
convenience methods that come with the bitcoin PublicKey type.

To use these convenience methods, drop the PubkeyHash and WPubkeyHash types
and just re-export the rust-bitcoin ones.

We keep the scripthash types separate because Elements Script is meaningfully
different from Bitcoin Script.

**Importantly**, because upstream our WPubkeyHash returns an error if you
try to give it an uncompressed public key, we panic in this case. The 'correct'
way to handle this would be to have distinct compressed/uncompressed public
key types, but those are not yet available from rust-bitcoin. Our current
behavior is to compute a "wpkh" output which is unspendable, which seems
like a very serious loss-of-funds problem, so we panic instead.

Author: apoelstra

src/address.rs

@@ -36,7 +36,7 @@ use crate::schnorr::{TapTweak, TweakedPublicKey, UntweakedPublicKey};
 use crate::taproot::TapNodeHash;
 
 use crate::{opcodes, script};
-use crate::{PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
+use crate::{PubkeyHash, ScriptHash, WScriptHash};
 
 /// Encoding error
 #[derive(Debug, PartialEq)]
@@ -236,13 +236,9 @@ impl Address {
         blinder: Option<secp256k1_zkp::PublicKey>,
         params: &'static AddressParams,
     ) -> Address {
-        let mut hash_engine = PubkeyHash::engine();
-        pk.write_into(&mut hash_engine)
-            .expect("engines don't error");
-
         Address {
             params,
-            payload: Payload::PubkeyHash(PubkeyHash::from_engine(hash_engine)),
+            payload: Payload::PubkeyHash(pk.pubkey_hash()),
             blinding_pubkey: blinder,
         }
     }
@@ -264,20 +260,20 @@ impl Address {
 
     /// Create a witness pay to public key address from a public key
     /// This is the native segwit address type for an output redeemable with a single signature
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided public key is not compressed.
     pub fn p2wpkh(
         pk: &PublicKey,
         blinder: Option<secp256k1_zkp::PublicKey>,
         params: &'static AddressParams,
     ) -> Address {
-        let mut hash_engine = WPubkeyHash::engine();
-        pk.write_into(&mut hash_engine)
-            .expect("engines don't error");
-
         Address {
             params,
             payload: Payload::WitnessProgram {
                 version: Fe32::Q,
-                program: WPubkeyHash::from_engine(hash_engine)[..].to_vec(),
+                program: pk.wpubkey_hash().expect("public key must be compressed").as_byte_array().to_vec(),
             },
             blinding_pubkey: blinder,
         }

src/hash_types.rs

@@ -20,6 +20,9 @@
 
 use crate::hashes::{hash160, hash_newtype, sha256, sha256d, Hash};
 
+// Re-export bitcoin's pubkeyhash types. We already re-export bitcoin's `PublicKey` type.
+pub use bitcoin::{PubkeyHash, WPubkeyHash};
+
 macro_rules! impl_hashencode {
     ($hashtype:ident) => {
         impl $crate::encode::Encodable for $hashtype {
@@ -52,12 +55,8 @@ hash_newtype! {
     /// "Hash of the transaction according to the signature algorithm"
     pub struct Sighash(sha256d::Hash);
 
-    /// A hash of a public key.
-    pub struct PubkeyHash(hash160::Hash);
     /// A hash of Bitcoin Script bytecode.
     pub struct ScriptHash(hash160::Hash);
-    /// SegWit version of a public key hash.
-    pub struct WPubkeyHash(hash160::Hash);
     /// SegWit version of a Bitcoin Script bytecode hash.
     pub struct WScriptHash(sha256::Hash);