diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index b7ce66d34..1b944bb7b 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -222,7 +222,7 @@ checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2"
 
 [[package]]
 name = "secp256k1"
-version = "0.31.0"
+version = "0.31.1"
 dependencies = [
  "bincode",
  "bitcoin_hashes",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 784b7faf4..c33758e78 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -213,7 +213,7 @@ checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
 [[package]]
 name = "secp256k1"
-version = "0.31.0"
+version = "0.31.1"
 dependencies = [
  "bincode",
  "bitcoin_hashes",
diff --git a/Cargo.toml b/Cargo.toml
index 6c870a955..71acbf4a2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "secp256k1"
-version = "0.31.0"
+version = "0.31.1"
 authors = [ "Dawid Ciężarkiewicz <dpc@ucore.info>",
             "Andrew Poelstra <apoelstra@wpsoftware.net>" ]
 license = "CC0-1.0"
diff --git a/examples/sign_verify.rs b/examples/sign_verify.rs
index cf86fe8e3..983646672 100644
--- a/examples/sign_verify.rs
+++ b/examples/sign_verify.rs
@@ -11,7 +11,7 @@ fn verify<C: Verification>(
     pubkey: [u8; 33],
 ) -> Result<bool, Error> {
     let msg = sha256::Hash::hash(msg);
-    let msg = Message::from_digest_slice(msg.as_ref())?;
+    let msg = Message::from_digest(msg.to_byte_array());
     let sig = ecdsa::Signature::from_compact(&sig)?;
     let pubkey = PublicKey::from_slice(&pubkey)?;
 
@@ -24,8 +24,8 @@ fn sign<C: Signing>(
     seckey: [u8; 32],
 ) -> Result<ecdsa::Signature, Error> {
     let msg = sha256::Hash::hash(msg);
-    let msg = Message::from_digest_slice(msg.as_ref())?;
-    let seckey = SecretKey::from_slice(&seckey)?;
+    let msg = Message::from_digest(msg.to_byte_array());
+    let seckey = SecretKey::from_byte_array(seckey)?;
     Ok(secp.sign_ecdsa(msg, &seckey))
 }
 
diff --git a/examples/sign_verify_recovery.rs b/examples/sign_verify_recovery.rs
index 984184def..78cbbd54e 100644
--- a/examples/sign_verify_recovery.rs
+++ b/examples/sign_verify_recovery.rs
@@ -11,7 +11,7 @@ fn recover<C: Verification>(
     recovery_id: u8,
 ) -> Result<PublicKey, Error> {
     let msg = sha256::Hash::hash(msg);
-    let msg = Message::from_digest_slice(msg.as_ref())?;
+    let msg = Message::from_digest(msg.to_byte_array());
     let id = ecdsa::RecoveryId::try_from(i32::from(recovery_id))?;
     let sig = ecdsa::RecoverableSignature::from_compact(&sig, id)?;
 
@@ -24,8 +24,8 @@ fn sign_recovery<C: Signing>(
     seckey: [u8; 32],
 ) -> Result<ecdsa::RecoverableSignature, Error> {
     let msg = sha256::Hash::hash(msg);
-    let msg = Message::from_digest_slice(msg.as_ref())?;
-    let seckey = SecretKey::from_slice(&seckey)?;
+    let msg = Message::from_digest(msg.to_byte_array());
+    let seckey = SecretKey::from_byte_array(seckey)?;
     Ok(secp.sign_ecdsa_recoverable(msg, &seckey))
 }
 
diff --git a/src/ecdh.rs b/src/ecdh.rs
index d8bc7950e..4fd90b788 100644
--- a/src/ecdh.rs
+++ b/src/ecdh.rs
@@ -64,7 +64,7 @@ impl SharedSecret {
     pub fn from_bytes(bytes: [u8; SHARED_SECRET_SIZE]) -> SharedSecret { SharedSecret(bytes) }
 
     /// Creates a shared secret from `bytes` slice.
-    #[deprecated(since = "TBD", note = "Use `from_bytes` instead.")]
+    #[deprecated(since = "0.31.0", note = "Use `from_bytes` instead.")]
     #[inline]
     pub fn from_slice(bytes: &[u8]) -> Result<SharedSecret, Error> {
         match bytes.len() {
@@ -178,7 +178,7 @@ impl<'de> ::serde::Deserialize<'de> for SharedSecret {
         } else {
             d.deserialize_bytes(super::serde_util::BytesVisitor::new(
                 "raw 32 bytes SharedSecret",
-                SharedSecret::from_slice,
+                |x| x.try_into().map(SharedSecret::from_bytes),
             ))
         }
     }
@@ -263,7 +263,7 @@ mod tests {
         ];
         static STR: &str = "01010101010101010001020304050607ffff0000ffff00006363636363636363";
 
-        let secret = SharedSecret::from_slice(&BYTES).unwrap();
+        let secret = SharedSecret::from_bytes(BYTES);
 
         assert_tokens(&secret.compact(), &[Token::BorrowedBytes(&BYTES[..])]);
         assert_tokens(&secret.compact(), &[Token::Bytes(&BYTES)]);
diff --git a/src/ecdsa/recovery.rs b/src/ecdsa/recovery.rs
index 62bc5a9f6..7c32efb42 100644
--- a/src/ecdsa/recovery.rs
+++ b/src/ecdsa/recovery.rs
@@ -271,7 +271,7 @@ mod tests {
         let full = Secp256k1::new();
 
         let msg = crate::random_32_bytes(&mut rand::rng());
-        let msg = Message::from_digest_slice(&msg).unwrap();
+        let msg = Message::from_digest(msg);
 
         // Try key generation
         let (sk, pk) = full.generate_keypair(&mut rand::rng());
@@ -302,8 +302,8 @@ mod tests {
         let mut s = Secp256k1::new();
         s.randomize(&mut rand::rng());
 
-        let sk = SecretKey::from_slice(&ONE).unwrap();
-        let msg = Message::from_digest_slice(&ONE).unwrap();
+        let sk = SecretKey::from_byte_array(ONE).unwrap();
+        let msg = Message::from_digest(ONE);
 
         let sig = s.sign_ecdsa_recoverable(msg, &sk);
 
@@ -327,8 +327,8 @@ mod tests {
         let mut s = Secp256k1::new();
         s.randomize(&mut rand::rng());
 
-        let sk = SecretKey::from_slice(&ONE).unwrap();
-        let msg = Message::from_digest_slice(&ONE).unwrap();
+        let sk = SecretKey::from_byte_array(ONE).unwrap();
+        let msg = Message::from_digest(ONE);
         let noncedata = [42u8; 32];
 
         let sig = s.sign_ecdsa_recoverable_with_noncedata(msg, &sk, &noncedata);
@@ -352,7 +352,7 @@ mod tests {
         s.randomize(&mut rand::rng());
 
         let msg = crate::random_32_bytes(&mut rand::rng());
-        let msg = Message::from_digest_slice(&msg).unwrap();
+        let msg = Message::from_digest(msg);
 
         let (sk, pk) = s.generate_keypair(&mut rand::rng());
 
@@ -360,7 +360,7 @@ mod tests {
         let sig = sigr.to_standard();
 
         let msg = crate::random_32_bytes(&mut rand::rng());
-        let msg = Message::from_digest_slice(&msg).unwrap();
+        let msg = Message::from_digest(msg);
         assert_eq!(s.verify_ecdsa(&sig, msg, &pk), Err(Error::IncorrectSignature));
 
         let recovered_key = s.recover_ecdsa(msg, &sigr).unwrap();
@@ -374,7 +374,7 @@ mod tests {
         s.randomize(&mut rand::rng());
 
         let msg = crate::random_32_bytes(&mut rand::rng());
-        let msg = Message::from_digest_slice(&msg).unwrap();
+        let msg = Message::from_digest(msg);
 
         let (sk, pk) = s.generate_keypair(&mut rand::rng());
 
@@ -390,7 +390,7 @@ mod tests {
         s.randomize(&mut rand::rng());
 
         let msg = crate::random_32_bytes(&mut rand::rng());
-        let msg = Message::from_digest_slice(&msg).unwrap();
+        let msg = Message::from_digest(msg);
 
         let noncedata = [42u8; 32];
 
@@ -407,7 +407,7 @@ mod tests {
         let mut s = Secp256k1::new();
         s.randomize(&mut rand::rng());
 
-        let msg = Message::from_digest_slice(&[0x55; 32]).unwrap();
+        let msg = Message::from_digest([0x55; 32]);
 
         // Zero is not a valid sig
         let sig = RecoverableSignature::from_compact(&[0; 64], RecoveryId::Zero).unwrap();
@@ -478,8 +478,8 @@ mod benches {
     pub fn bench_recover(bh: &mut Bencher) {
         let s = Secp256k1::new();
         let msg = crate::random_32_bytes(&mut rand::rng());
-        let msg = Message::from_digest_slice(&msg).unwrap();
-        let (sk, _) = s.generate_keypair(&mut rand::rng());
+        let msg = Message::from_digest(msg);
+        let (sk, _) = s.generate_keypair(&mut rand::thread_rng());
         let sig = s.sign_ecdsa_recoverable(&msg, &sk);
 
         bh.iter(|| {
diff --git a/src/ecdsa/serialized_signature.rs b/src/ecdsa/serialized_signature.rs
index f8be36a29..5fb69c3ca 100644
--- a/src/ecdsa/serialized_signature.rs
+++ b/src/ecdsa/serialized_signature.rs
@@ -54,7 +54,7 @@ impl PartialEq<SerializedSignature> for [u8] {
 
 impl PartialOrd for SerializedSignature {
     fn partial_cmp(&self, other: &SerializedSignature) -> Option<core::cmp::Ordering> {
-        Some((**self).cmp(&**other))
+        Some(self.cmp(other))
     }
 }
 
diff --git a/src/ellswift.rs b/src/ellswift.rs
index c3007f34b..11877fb03 100644
--- a/src/ellswift.rs
+++ b/src/ellswift.rs
@@ -378,7 +378,7 @@ mod tests {
         // Test that we can round trip an ElligatorSwift encoding
         let secp = crate::Secp256k1::new();
         let public_key =
-            PublicKey::from_secret_key(&secp, &SecretKey::from_slice(&[1u8; 32]).unwrap());
+            PublicKey::from_secret_key(&secp, &SecretKey::from_byte_array([1u8; 32]).unwrap());
 
         let ell = ElligatorSwift::from_pubkey(public_key);
         let pk = PublicKey::from_ellswift(ell);
@@ -391,9 +391,11 @@ mod tests {
         let secp = crate::Secp256k1::new();
         let rand32 = [1u8; 32];
         let priv32 = [1u8; 32];
-        let ell = ElligatorSwift::from_seckey(&secp, SecretKey::from_slice(&rand32).unwrap(), None);
+        let ell =
+            ElligatorSwift::from_seckey(&secp, SecretKey::from_byte_array(rand32).unwrap(), None);
         let pk = PublicKey::from_ellswift(ell);
-        let expected = PublicKey::from_secret_key(&secp, &SecretKey::from_slice(&priv32).unwrap());
+        let expected =
+            PublicKey::from_secret_key(&secp, &SecretKey::from_byte_array(priv32).unwrap());
 
         assert_eq!(pk, expected);
     }
@@ -406,13 +408,13 @@ mod tests {
         let priv32 = [2u8; 32];
         let ell = ElligatorSwift::from_seckey(
             &secp,
-            SecretKey::from_slice(&rand32).unwrap(),
+            SecretKey::from_byte_array(rand32).unwrap(),
             Some(rand32),
         );
         let pk = ElligatorSwift::shared_secret_with_hasher(
             ell,
             ell,
-            SecretKey::from_slice(&priv32).unwrap(),
+            SecretKey::from_byte_array(priv32).unwrap(),
             Party::Initiator,
             |_, _, _| ElligatorSwiftSharedSecret([0xff; 32]),
         );
@@ -626,7 +628,7 @@ mod tests {
                     ElligatorSwift::from_array(ellswift_theirs),
                 )
             };
-            let sec_key = SecretKey::from_slice(&my_secret).unwrap();
+            let sec_key = SecretKey::from_byte_array(my_secret).unwrap();
             let initiator = if initiator == 0 { Party::Responder } else { Party::Initiator };
 
             let shared = ElligatorSwift::shared_secret(el_a, el_b, sec_key, initiator, None);
diff --git a/src/key.rs b/src/key.rs
index 6b1dcd645..3aef6302b 100644
--- a/src/key.rs
+++ b/src/key.rs
@@ -220,7 +220,7 @@ impl SecretKey {
     /// use secp256k1::SecretKey;
     /// let sk = SecretKey::from_slice(&[0xcd; 32]).expect("32 bytes, within curve order");
     /// ```
-    #[deprecated(since = "TBD", note = "Use `from_byte_array` instead.")]
+    #[deprecated(since = "0.31.0", note = "Use `from_byte_array` instead.")]
     #[inline]
     pub fn from_slice(data: &[u8]) -> Result<SecretKey, Error> {
         match <[u8; constants::SECRET_KEY_SIZE]>::try_from(data) {
@@ -402,10 +402,10 @@ impl<'de> serde::Deserialize<'de> for SecretKey {
                 "a hex string representing 32 byte SecretKey",
             ))
         } else {
-            let visitor =
-                super::serde_util::Tuple32Visitor::new("raw 32 bytes SecretKey", |bytes| {
-                    SecretKey::from_byte_array(bytes)
-                });
+            let visitor = super::serde_util::Tuple32Visitor::new(
+                "raw 32 bytes SecretKey",
+                SecretKey::from_byte_array,
+            );
             d.deserialize_tuple(constants::SECRET_KEY_SIZE, visitor)
         }
     }
@@ -791,10 +791,10 @@ impl<'de> serde::Deserialize<'de> for PublicKey {
                 "an ASCII hex string representing a public key",
             ))
         } else {
-            let visitor =
-                super::serde_util::Tuple33Visitor::new("33 bytes compressed public key", |bytes| {
-                    PublicKey::from_byte_array_compressed(bytes)
-                });
+            let visitor = super::serde_util::Tuple33Visitor::new(
+                "33 bytes compressed public key",
+                PublicKey::from_byte_array_compressed,
+            );
             d.deserialize_tuple(constants::PUBLIC_KEY_SIZE, visitor)
         }
     }
@@ -861,7 +861,7 @@ impl Keypair {
     ///
     /// [`Error::InvalidSecretKey`] if the slice is not exactly 32 bytes long,
     /// or if the encoded number is an invalid scalar.
-    #[deprecated(since = "TBD", note = "Use `from_seckey_byte_array` instead.")]
+    #[deprecated(since = "0.31.0", note = "Use `from_seckey_byte_array` instead.")]
     #[inline]
     pub fn from_seckey_slice<C: Signing>(
         secp: &Secp256k1<C>,
@@ -1240,7 +1240,7 @@ impl XOnlyPublicKey {
     ///
     /// Returns [`Error::InvalidPublicKey`] if the length of the data slice is not 32 bytes or the
     /// slice does not represent a valid Secp256k1 point x coordinate.
-    #[deprecated(since = "TBD", note = "Use `from_byte_array` instead.")]
+    #[deprecated(since = "0.31.0", note = "Use `from_byte_array` instead.")]
     #[inline]
     pub fn from_slice(data: &[u8]) -> Result<XOnlyPublicKey, Error> {
         match <[u8; constants::SCHNORR_PUBLIC_KEY_SIZE]>::try_from(data) {
@@ -1673,6 +1673,7 @@ mod test {
     use crate::{constants, from_hex, to_hex, Scalar};
 
     #[test]
+    #[allow(deprecated)]
     fn skey_from_slice() {
         let sk = SecretKey::from_slice(&[1; 31]);
         assert_eq!(sk, Err(InvalidSecretKey));
@@ -1707,7 +1708,7 @@ mod test {
         let s = Secp256k1::new();
 
         let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
-        assert_eq!(SecretKey::from_slice(&sk1[..]), Ok(sk1));
+        assert_eq!(SecretKey::from_byte_array(sk1.secret_bytes()), Ok(sk1));
         assert_eq!(PublicKey::from_slice(&pk1.serialize()[..]), Ok(pk1));
         assert_eq!(PublicKey::from_slice(&pk1.serialize_uncompressed()[..]), Ok(pk1));
     }
@@ -1727,22 +1728,22 @@ mod test {
     #[rustfmt::skip]
     fn invalid_secret_key() {
         // Zero
-        assert_eq!(SecretKey::from_slice(&[0; 32]), Err(InvalidSecretKey));
+        assert_eq!(SecretKey::from_byte_array([0; 32]), Err(InvalidSecretKey));
         assert_eq!(
             SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000000"),
             Err(InvalidSecretKey)
         );
         // -1
-        assert_eq!(SecretKey::from_slice(&[0xff; 32]), Err(InvalidSecretKey));
+        assert_eq!(SecretKey::from_byte_array([0xff; 32]), Err(InvalidSecretKey));
         // Top of range
-        assert!(SecretKey::from_slice(&[
+        assert!(SecretKey::from_byte_array([
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
             0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
             0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x40,
         ]).is_ok());
         // One past top of range
-        assert!(SecretKey::from_slice(&[
+        assert!(SecretKey::from_byte_array([
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
             0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
@@ -1811,6 +1812,7 @@ mod test {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_seckey_from_bad_slice() {
         // Bad sizes
         assert_eq!(
@@ -1864,7 +1866,7 @@ mod test {
 
         #[cfg(not(secp256k1_fuzz))]
         let s = Secp256k1::signing_only();
-        let sk = SecretKey::from_slice(&SK_BYTES).expect("sk");
+        let sk = SecretKey::from_byte_array(SK_BYTES).expect("sk");
 
         // In fuzzing mode secret->public key derivation is different, so
         // hard-code the expected result.
@@ -2219,7 +2221,7 @@ mod test {
 
         #[cfg(not(secp256k1_fuzz))]
         let s = Secp256k1::new();
-        let sk = SecretKey::from_slice(&SK_BYTES).unwrap();
+        let sk = SecretKey::from_byte_array(SK_BYTES).unwrap();
 
         // In fuzzing mode secret->public key derivation is different, so
         // hard-code the expected result.
@@ -2359,10 +2361,11 @@ mod test {
         pk_bytes[0] = 0x02; // Use positive Y co-ordinate.
         pk_bytes[1..].clone_from_slice(&PK_BYTES);
 
-        let sk = SecretKey::from_slice(&SK_BYTES).expect("failed to parse sk bytes");
+        let sk = SecretKey::from_byte_array(SK_BYTES).expect("failed to parse sk bytes");
         let pk = PublicKey::from_slice(&pk_bytes).expect("failed to create pk from iterator");
         let kp = Keypair::from_secret_key(&secp, &sk);
-        let xonly = XOnlyPublicKey::from_slice(&PK_BYTES).expect("failed to get xonly from slice");
+        let xonly =
+            XOnlyPublicKey::from_byte_array(PK_BYTES).expect("failed to get xonly from slice");
 
         (sk, pk, kp, xonly)
     }
diff --git a/src/lib.rs b/src/lib.rs
index 40dc490ad..ffc8038c1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -256,7 +256,7 @@ impl Message {
     ///
     /// [secure signature]: https://twitter.com/pwuille/status/1063582706288586752
     #[inline]
-    #[deprecated(since = "TBD", note = "use from_digest instead")]
+    #[deprecated(since = "0.31.0", note = "use from_digest instead")]
     pub fn from_digest_slice(digest: &[u8]) -> Result<Message, Error> {
         Ok(Message::from_digest(digest.try_into().map_err(|_| Error::InvalidMessage)?))
     }
@@ -641,9 +641,9 @@ mod tests {
         assert!(full.verify_ecdsa(&sig, msg, &pk).is_ok());
 
         // Check that we can produce keys from slices with no precomputation
-        let (pk_slice, sk_slice) = (&pk.serialize(), &sk[..]);
+        let pk_slice = &pk.serialize();
         let new_pk = PublicKey::from_slice(pk_slice).unwrap();
-        let new_sk = SecretKey::from_slice(sk_slice).unwrap();
+        let new_sk = SecretKey::from_byte_array(sk.secret_bytes()).unwrap();
         assert_eq!(sk, new_sk);
         assert_eq!(pk, new_pk);
     }
@@ -793,7 +793,7 @@ mod tests {
         wild_keys[1][0] -= 1;
         wild_msgs[1][0] -= 1;
 
-        for key in wild_keys.iter().map(|k| SecretKey::from_slice(&k[..]).unwrap()) {
+        for key in wild_keys.iter().copied().map(SecretKey::from_byte_array).map(Result::unwrap) {
             for msg in wild_msgs.into_iter().map(Message::from_digest) {
                 let sig = s.sign_ecdsa(msg, &key);
                 let low_r_sig = s.sign_ecdsa_low_r(msg, &key);
@@ -965,7 +965,7 @@ mod tests {
         let s = Secp256k1::new();
 
         let msg = Message::from_digest([1; 32]);
-        let sk = SecretKey::from_slice(&[2; 32]).unwrap();
+        let sk = SecretKey::from_byte_array([2; 32]).unwrap();
         let sig = s.sign_ecdsa(msg, &sk);
         static SIG_BYTES: [u8; 71] = [
             48, 69, 2, 33, 0, 157, 11, 173, 87, 103, 25, 211, 42, 231, 107, 237, 179, 76, 119, 72,
@@ -992,7 +992,7 @@ mod tests {
     fn test_global_context() {
         use crate::SECP256K1;
         let sk_data = hex!("e6dd32f8761625f105c39a39f19370b3521d845a12456d60ce44debd0a362641");
-        let sk = SecretKey::from_slice(&sk_data).unwrap();
+        let sk = SecretKey::from_byte_array(sk_data).unwrap();
         let msg_data = hex!("a4965ca63b7d8562736ceec36dfa5a11bf426eb65be8ea3f7a49ae363032da0d");
         let msg = Message::from_digest(msg_data);
 
diff --git a/src/musig.rs b/src/musig.rs
index 7cec106d4..06bea1a07 100644
--- a/src/musig.rs
+++ b/src/musig.rs
@@ -1017,9 +1017,7 @@ impl AggregatedSignature {
     /// Note that while an alternative approach of verifying partial signatures is valid, verifying the aggregated
     /// signature is more performant. Thus it should be generally better to verify the signature using this function first
     /// and fall back to detection of violators if it fails.
-    pub fn assume_valid(self) -> schnorr::Signature {
-        schnorr::Signature::from_slice(&self.0).expect("Invalid signature data")
-    }
+    pub fn assume_valid(self) -> schnorr::Signature { schnorr::Signature::from_byte_array(self.0) }
 
     /// Verify the aggregated signature against the aggregate public key and message
     /// before returning the signature.
@@ -1029,7 +1027,7 @@ impl AggregatedSignature {
         aggregate_key: &XOnlyPublicKey,
         message: &[u8],
     ) -> Result<schnorr::Signature, Error> {
-        let sig = schnorr::Signature::from_slice(&self.0)?;
+        let sig = schnorr::Signature::from_byte_array(self.0);
         secp.verify_schnorr(&sig, message, aggregate_key)
             .map(|_| sig)
             .map_err(|_| Error::IncorrectSignature)
diff --git a/src/schnorr.rs b/src/schnorr.rs
index 8c0305fd8..45c35d9db 100644
--- a/src/schnorr.rs
+++ b/src/schnorr.rs
@@ -42,7 +42,7 @@ impl<'de> serde::Deserialize<'de> for Signature {
         } else {
             d.deserialize_bytes(super::serde_util::BytesVisitor::new(
                 "raw 64 bytes schnorr signature",
-                Signature::from_slice,
+                |x| x.try_into().map(Signature::from_byte_array),
             ))
         }
     }
@@ -78,7 +78,7 @@ impl Signature {
     pub fn from_byte_array(sig: [u8; constants::SCHNORR_SIGNATURE_SIZE]) -> Self { Self(sig) }
 
     /// Creates a `Signature` directly from a slice.
-    #[deprecated(since = "TBD", note = "Use `from_byte_array` instead.")]
+    #[deprecated(since = "0.31.0", note = "Use `from_byte_array` instead.")]
     #[inline]
     pub fn from_slice(data: &[u8]) -> Result<Signature, Error> {
         match data.len() {
@@ -92,7 +92,7 @@ impl Signature {
     }
 
     /// Returns a signature as a byte array.
-    #[deprecated(since = "0.30.0", note = "Use `to_byte_array` instead.")]
+    #[deprecated(since = "0.31.0", note = "Use `to_byte_array` instead.")]
     pub fn serialize(&self) -> [u8; constants::SCHNORR_SIGNATURE_SIZE] { self.0 }
 
     /// Returns a signature as a byte array.
@@ -317,6 +317,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_pubkey_from_slice() {
         let pk = XOnlyPublicKey::from_slice(&[
             0xB3, 0x3C, 0xC9, 0xED, 0xC0, 0x96, 0xD0, 0xA8, 0x34, 0x16, 0x96, 0x4B, 0xD3, 0xC6,
@@ -327,6 +328,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_pubkey_from_bad_slice() {
         // Bad sizes
         assert_eq!(XOnlyPublicKey::from_slice(&[]), Err(InvalidPublicKey));
@@ -363,7 +365,7 @@ mod tests {
         let (pk, _parity) = kp.x_only_public_key();
 
         let ser = pk.serialize();
-        let pubkey2 = XOnlyPublicKey::from_slice(&ser).unwrap();
+        let pubkey2 = XOnlyPublicKey::from_byte_array(ser).unwrap();
         assert_eq!(pk, pubkey2);
     }
 
@@ -492,7 +494,7 @@ mod tests {
             170, 12, 208, 84, 74, 200, 135, 254, 145, 221, 209, 102,
         ];
         static PK_STR: &str = "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166";
-        let pk = XOnlyPublicKey::from_slice(&PK_BYTES).unwrap();
+        let pk = XOnlyPublicKey::from_byte_array(PK_BYTES).unwrap();
 
         assert_tokens(&sig.compact(), &[Token::BorrowedBytes(&SIG_BYTES[..])]);
         assert_tokens(&sig.compact(), &[Token::Bytes(&SIG_BYTES[..])]);
@@ -712,7 +714,7 @@ mod tests {
                 assert_eq!(sig.to_byte_array(), signature);
             }
             let sig = Signature::from_byte_array(signature);
-            let is_verified = if let Ok(pubkey) = XOnlyPublicKey::from_slice(&public_key) {
+            let is_verified = if let Ok(pubkey) = XOnlyPublicKey::from_byte_array(public_key) {
                 secp.verify_schnorr(&sig, &message, &pubkey).is_ok()
             } else {
                 false
diff --git a/tests/serde.rs b/tests/serde.rs
index b46d1e919..4df4db990 100644
--- a/tests/serde.rs
+++ b/tests/serde.rs
@@ -73,7 +73,7 @@ static MUSIG_PARTIAL_SIG_BYTES: [u8; 40] = [
 ];
 
 fn secret_key() -> SecretKey {
-    SecretKey::from_slice(&SK_BYTES).expect("failed to create sk from slice")
+    SecretKey::from_byte_array(SK_BYTES).expect("failed to create sk from slice")
 }
 
 // Our current serde serialization implementation is only guaranteed to be fixed
@@ -106,8 +106,8 @@ fn bincode_keypair() {
 
 #[test]
 fn bincode_x_only_public_key() {
-    let pk =
-        XOnlyPublicKey::from_slice(&XONLY_PK_BYTES).expect("failed to create xonly pk from slice");
+    let pk = XOnlyPublicKey::from_byte_array(XONLY_PK_BYTES)
+        .expect("failed to create xonly pk from slice");
     let ser = bincode::serialize(&pk).unwrap();
 
     assert_eq!(ser, XONLY_PK_BYTES);