Stop implementing ThirtyTwoByteHash

The implementations of `ThirtyTwoByteHash` for types from the `hashes`
crate are problematic during upgrades because both `bitcoin` and
`secp256k1` depend on `hashes` and when the versions of `hashes` get out
of sync usage of the trait breaks.

- Deprecate `ThirtyTwoByteHash`
- Remove the two `from_hashed_data` functions

Author: tcharding

api/all-features.txt

@@ -519,8 +519,6 @@ impl secp256k1_sys::CPtr for secp256k1::PublicKey
 impl secp256k1_sys::CPtr for secp256k1::schnorr::Signature
 impl secp256k1_sys::CPtr for secp256k1::SecretKey
 impl secp256k1_sys::CPtr for secp256k1::XOnlyPublicKey
-impl secp256k1::ThirtyTwoByteHash for bitcoin_hashes::sha256d::Hash
-impl secp256k1::ThirtyTwoByteHash for bitcoin_hashes::sha256::Hash
 impl secp256k1::Verification for secp256k1::All
 impl secp256k1::Verification for secp256k1::VerifyOnly
 impl secp256k1::XOnlyPublicKey
@@ -532,7 +530,6 @@ impl serde::ser::Serialize for secp256k1::PublicKey
 impl serde::ser::Serialize for secp256k1::schnorr::Signature
 impl serde::ser::Serialize for secp256k1::SecretKey
 impl serde::ser::Serialize for secp256k1::XOnlyPublicKey
-impl<T: bitcoin_hashes::sha256t::Tag> secp256k1::ThirtyTwoByteHash for bitcoin_hashes::sha256t::Hash<T>
 impl<T: secp256k1::ThirtyTwoByteHash> core::convert::From<T> for secp256k1::Message
 impl<T: secp256k1::ThirtyTwoByteHash> core::convert::From<T> for secp256k1::SecretKey
 #[non_exhaustive] pub struct secp256k1::scalar::OutOfRangeError
@@ -580,9 +577,6 @@ pub enum secp256k1::SignOnly
 pub enum secp256k1::VerifyOnly
 pub extern crate secp256k1::hashes
 pub fn &'a secp256k1::ecdsa::serialized_signature::SerializedSignature::into_iter(self) -> Self::IntoIter
-pub fn bitcoin_hashes::sha256d::Hash::into_32(self) -> [u8; 32]
-pub fn bitcoin_hashes::sha256::Hash::into_32(self) -> [u8; 32]
-pub fn bitcoin_hashes::sha256t::Hash<T>::into_32(self) -> [u8; 32]
 pub fn i32::from(parity: secp256k1::Parity) -> i32
 pub fn secp256k1::All::clone(&self) -> secp256k1::All
 pub fn secp256k1::All::cmp(&self, other: &secp256k1::All) -> core::cmp::Ordering
@@ -772,7 +766,6 @@ pub fn secp256k1::Message::eq(&self, other: &secp256k1::Message) -> bool
 pub fn secp256k1::Message::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn secp256k1::Message::from_digest(digest: [u8; 32]) -> secp256k1::Message
 pub fn secp256k1::Message::from_digest_slice(digest: &[u8]) -> core::result::Result<secp256k1::Message, secp256k1::Error>
-pub fn secp256k1::Message::from_hashed_data<H: secp256k1::ThirtyTwoByteHash + bitcoin_hashes::Hash>(data: &[u8]) -> Self
 pub fn secp256k1::Message::from_slice(digest: &[u8]) -> core::result::Result<secp256k1::Message, secp256k1::Error>
 pub fn secp256k1::Message::from(t: T) -> secp256k1::Message
 pub fn secp256k1::Message::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
@@ -904,7 +897,6 @@ pub fn secp256k1::SecretKey::deserialize<D: serde::de::Deserializer<'de>>(d: D)
 pub fn secp256k1::SecretKey::display_secret(&self) -> DisplaySecret
 pub fn secp256k1::SecretKey::eq(&self, other: &Self) -> bool
 pub fn secp256k1::SecretKey::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn secp256k1::SecretKey::from_hashed_data<H: secp256k1::ThirtyTwoByteHash + bitcoin_hashes::Hash>(data: &[u8]) -> Self
 pub fn secp256k1::SecretKey::from_keypair(keypair: &secp256k1::Keypair) -> Self
 pub fn secp256k1::SecretKey::from(pair: &'a secp256k1::Keypair) -> Self
 pub fn secp256k1::SecretKey::from(pair: secp256k1::Keypair) -> Self

src/key.rs

@@ -257,30 +257,6 @@ impl SecretKey {
         SecretKey(sk)
     }
 
-    /// Constructs a [`SecretKey`] by hashing `data` with hash algorithm `H`.
-    ///
-    /// Requires the feature `hashes` to be enabled.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #[cfg(feature="hashes")] {
-    /// use secp256k1::hashes::{sha256, Hash};
-    /// use secp256k1::SecretKey;
-    ///
-    /// let sk1 = SecretKey::from_hashed_data::<sha256::Hash>("Hello world!".as_bytes());
-    /// // is equivalent to
-    /// let sk2 = SecretKey::from(sha256::Hash::hash("Hello world!".as_bytes()));
-    ///
-    /// assert_eq!(sk1, sk2);
-    /// # }
-    /// ```
-    #[cfg(feature = "hashes")]
-    #[inline]
-    pub fn from_hashed_data<H: ThirtyTwoByteHash + hashes::Hash>(data: &[u8]) -> Self {
-        <H as hashes::Hash>::hash(data).into()
-    }
-
     /// Returns the secret key as a byte value.
     #[inline]
     pub fn secret_bytes(&self) -> [u8; constants::SECRET_KEY_SIZE] { self.0 }

src/lib.rs

@@ -35,7 +35,7 @@
 //!
 //! let secp = Secp256k1::new();
 //! let (secret_key, public_key) = secp.generate_keypair(&mut OsRng);
-//! let message = Message::from_hashed_data::<sha256::Hash>("Hello World!".as_bytes());
+//! let message = Message::from(sha256::Hash::hash("Hello world!".as_bytes()));
 //!
 //! let sig = secp.sign_ecdsa(&message, &secret_key);
 //! assert!(secp.verify_ecdsa(&message, &sig, &public_key).is_ok());
@@ -50,7 +50,7 @@
 //! use secp256k1::hashes::sha256;
 //!
 //! let (secret_key, public_key) = generate_keypair(&mut rand::thread_rng());
-//! let message = Message::from_hashed_data::<sha256::Hash>("Hello World!".as_bytes());
+//! let message = Message::from(sha256::Hash::hash("Hello world!".as_bytes()));
 //!
 //! let sig = secret_key.sign_ecdsa(message);
 //! assert!(sig.verify(&message, &public_key).is_ok());
@@ -176,8 +176,6 @@ use core::{fmt, mem, str};
 
 #[cfg(all(feature = "global-context", feature = "std"))]
 pub use context::global::{self, SECP256K1};
-#[cfg(feature = "hashes")]
-use hashes::Hash;
 #[cfg(feature = "rand")]
 pub use rand;
 pub use secp256k1_sys as ffi;
@@ -198,34 +196,20 @@ pub use crate::scalar::Scalar;
 /// Trait describing something that promises to be a 32-byte random number; in particular,
 /// it has negligible probability of being zero or overflowing the group order. Such objects
 /// may be converted to `Message`s without any error paths.
+#[deprecated(since = "0.29.0", note = "this will be removed soon")]
 pub trait ThirtyTwoByteHash {
     /// Converts the object into a 32-byte array
     fn into_32(self) -> [u8; 32];
 }
 
-#[cfg(feature = "hashes")]
-impl ThirtyTwoByteHash for hashes::sha256::Hash {
-    fn into_32(self) -> [u8; 32] { self.to_byte_array() }
-}
-
-#[cfg(feature = "hashes")]
-impl ThirtyTwoByteHash for hashes::sha256d::Hash {
-    fn into_32(self) -> [u8; 32] { self.to_byte_array() }
-}
-
-#[cfg(feature = "hashes")]
-impl<T: hashes::sha256t::Tag> ThirtyTwoByteHash for hashes::sha256t::Hash<T> {
-    fn into_32(self) -> [u8; 32] { self.to_byte_array() }
-}
-
 /// A (hashed) message input to an ECDSA signature.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Message([u8; constants::MESSAGE_SIZE]);
 impl_array_newtype!(Message, u8, constants::MESSAGE_SIZE);
 impl_pretty_debug!(Message);
 
 impl Message {
-    /// **If you just want to sign an arbitrary message use `Message::from_hashed_data` instead.**
+    /// Creates a [`Message`] from a 32 byte slice `digest`.
     ///
     /// Converts a `MESSAGE_SIZE`-byte slice to a message object. **WARNING:** the slice has to be a
     /// cryptographically secure hash of the actual message that's going to be signed. Otherwise
@@ -239,8 +223,6 @@ impl Message {
 
     /// Creates a [`Message`] from a `digest`.
     ///
-    /// **If you just want to sign an arbitrary message use `Message::from_hashed_data` instead.**
-    ///
     /// The `digest` array has to be a cryptographically secure hash of the actual message that's
     /// going to be signed. Otherwise the result of signing isn't a [secure signature].
     ///
@@ -250,8 +232,6 @@ impl Message {
 
     /// Creates a [`Message`] from a 32 byte slice `digest`.
     ///
-    /// **If you just want to sign an arbitrary message use `Message::from_hashed_data` instead.**
-    ///
     /// The slice has to be 32 bytes long and be a cryptographically secure hash of the actual
     /// message that's going to be signed. Otherwise the result of signing isn't a [secure
     /// signature].
@@ -272,29 +252,6 @@ impl Message {
             _ => Err(Error::InvalidMessage),
         }
     }
-
-    /// Constructs a [`Message`] by hashing `data` with hash algorithm `H`.
-    ///
-    /// Requires the feature `hashes` to be enabled.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #[cfg(feature = "hashes")] {
-    /// use secp256k1::hashes::{sha256, Hash};
-    /// use secp256k1::Message;
-    ///
-    /// let m1 = Message::from_hashed_data::<sha256::Hash>("Hello world!".as_bytes());
-    /// // is equivalent to
-    /// let m2 = Message::from(sha256::Hash::hash("Hello world!".as_bytes()));
-    ///
-    /// assert_eq!(m1, m2);
-    /// # }
-    /// ```
-    #[cfg(feature = "hashes")]
-    pub fn from_hashed_data<H: ThirtyTwoByteHash + hashes::Hash>(data: &[u8]) -> Self {
-        <H as hashes::Hash>::hash(data).into()
-    }
 }
 
 impl<T: ThirtyTwoByteHash> From<T> for Message {
@@ -1043,24 +1000,6 @@ mod tests {
         let sig = SECP256K1.sign_ecdsa(&msg, &sk);
         assert!(SECP256K1.verify_ecdsa(&msg, &sig, &pk).is_ok());
     }
-
-    #[cfg(feature = "hashes")]
-    #[test]
-    fn test_from_hash() {
-        use hashes::{sha256, sha256d, Hash};
-
-        let test_bytes = "Hello world!".as_bytes();
-
-        let hash = sha256::Hash::hash(test_bytes);
-        let msg = Message::from(hash);
-        assert_eq!(msg.0, hash.to_byte_array());
-        assert_eq!(msg, Message::from_hashed_data::<hashes::sha256::Hash>(test_bytes));
-
-        let hash = sha256d::Hash::hash(test_bytes);
-        let msg = Message::from(hash);
-        assert_eq!(msg.0, hash.to_byte_array());
-        assert_eq!(msg, Message::from_hashed_data::<hashes::sha256d::Hash>(test_bytes));
-    }
 }
 
 #[cfg(bench)]