Merge rust-bitcoin/rust-bitcoin#3301: Deprecate `from_slice` methods in favor of arrays

c00afe8d52 Change MessageSignatureError to secp256k1::Error (Jamil Lambert, PhD)
a20d0bc4eb Deprecate `from_slice()` in sha256.rs (Jamil Lambert, PhD)
089043546f Deprecate `from_slice` methods in favor of arrays (Jamil Lambert, PhD)

Pull request description:

  As brought up in issue #3102 support for Rust arrays is now much better so slice-accepting methods that require a fixed length can be replaced with a method that accepts an array.

  `from_slice()` methods that require a fixed length have been deprecated and where needed a `from_byte_array()` method created that accepts an array.

  There are still `from_slice` methods that rely on changes to external crates before they can be changed to arrays.

ACKs for top commit:
  apoelstra:
    ACK c00afe8d52 successfully ran local tests
  tcharding:
    ACK c00afe8d52
  Kixunil:
    ACK c00afe8d52

Tree-SHA512: c505b78d5ca57e7e1004df6761ac6760d5d9b63c93edc6ac1f9adf047bc67011883575f835b06f6d35d7f6c2b6a4c6c7f0a82a3f0e293bfb4ef58123b75d3809

bitcoin/src/sign_message.rs

@@ -108,16 +108,13 @@ mod message_signing {
             serialized
         }
 
-        /// Create from a byte slice.
-        pub fn from_slice(bytes: &[u8]) -> Result<MessageSignature, MessageSignatureError> {
-            if bytes.len() != 65 {
-                return Err(MessageSignatureError::InvalidLength);
-            }
+        /// Creates a `MessageSignature` from a fixed-length array.
+        pub fn from_byte_array(
+            bytes: &[u8; 65],
+        ) -> Result<MessageSignature, secp256k1::Error> {
             // We just check this here so we can safely subtract further.
             if bytes[0] < 27 {
-                return Err(MessageSignatureError::InvalidEncoding(
-                    secp256k1::Error::InvalidRecoveryId,
-                ));
+                return Err(secp256k1::Error::InvalidRecoveryId);
             };
             let recid = RecoveryId::from_i32(((bytes[0] - 27) & 0x03) as i32)?;
             Ok(MessageSignature {
@@ -126,6 +123,14 @@ mod message_signing {
             })
         }
 
+        /// Create a `MessageSignature` from a byte slice.
+        #[deprecated(since = "TBD", note = "Use `from_byte_array` instead.")]
+        pub fn from_slice(bytes: &[u8]) -> Result<MessageSignature, MessageSignatureError> {
+            let byte_array: [u8; 65] =
+                bytes.try_into().map_err(|_| MessageSignatureError::InvalidLength)?;
+            Self::from_byte_array(&byte_array).map_err(MessageSignatureError::from)
+        }
+
         /// Attempt to recover a public key from the signature and the signed message.
         ///
         /// To get the message hash from a message, use [super::signed_msg_hash].
@@ -170,9 +175,14 @@ mod message_signing {
         impl MessageSignature {
             /// Convert a signature from base64 encoding.
             pub fn from_base64(s: &str) -> Result<MessageSignature, MessageSignatureError> {
-                let bytes =
-                    BASE64_STANDARD.decode(s).map_err(|_| MessageSignatureError::InvalidBase64)?;
-                MessageSignature::from_slice(&bytes)
+                if s.len() != 88 {
+                    return Err(MessageSignatureError::InvalidLength);
+                }
+                let mut byte_array = [0; 65];
+                BASE64_STANDARD
+                    .decode_slice_unchecked(s, &mut byte_array)
+                    .map_err(|_| MessageSignatureError::InvalidBase64)?;
+                MessageSignature::from_byte_array(&byte_array).map_err(MessageSignatureError::from)
             }
 
             /// Convert to base64 encoding.
@@ -258,6 +268,10 @@ mod tests {
         assert_eq!(signature2.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(true));
 
         assert_eq!(pubkey.0, secp256k1::PublicKey::from_secret_key(&secp, &privkey));
+        let signature_base64 = signature.to_base64();
+        let signature_round_trip =
+            super::MessageSignature::from_base64(&signature_base64).expect("message signature");
+        assert_eq!(signature, signature_round_trip);
     }
 
     #[test]

hashes/src/sha256t.rs

@@ -71,13 +71,14 @@ where
     pub fn from_engine(e: HashEngine) -> Hash<T> { from_engine(e) }
 
     /// Copies a byte slice into a hash object.
+    #[deprecated(since = "TBD", note = "Use `from_byte_array` instead.")]
     pub fn from_slice(sl: &[u8]) -> Result<Hash<T>, FromSliceError> {
         if sl.len() != 32 {
             Err(FromSliceError { expected: 32, got: sl.len() })
         } else {
             let mut ret = [0; 32];
             ret.copy_from_slice(sl);
-            Ok(Self::internal_new(ret))
+            Ok(Self::from_byte_array(ret))
         }
     }