Deprecate and replace from_slice

The PrivateKey and XOnlyPublicKey from_slice functions have been
deprecated and calls to them from within the crate have been changed to
use the equivalent array function.

src/ecdh.rs

@@ -64,6 +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.")]
     #[inline]
     pub fn from_slice(bytes: &[u8]) -> Result<SharedSecret, Error> {
         match bytes.len() {

src/key.rs

@@ -115,7 +115,7 @@ impl str::FromStr for SecretKey {
     fn from_str(s: &str) -> Result<SecretKey, Error> {
         let mut res = [0u8; constants::SECRET_KEY_SIZE];
         match from_hex(s, &mut res) {
-            Ok(constants::SECRET_KEY_SIZE) => SecretKey::from_slice(&res),
+            Ok(constants::SECRET_KEY_SIZE) => SecretKey::from_byte_array(&res),
             _ => Err(Error::InvalidSecretKey),
         }
     }
@@ -138,7 +138,7 @@ impl str::FromStr for SecretKey {
 /// use secp256k1::{SecretKey, Secp256k1, PublicKey};
 ///
 /// let secp = Secp256k1::new();
-/// let secret_key = SecretKey::from_slice(&[0xcd; 32]).expect("32 bytes, within curve order");
+/// let secret_key = SecretKey::from_byte_array(&[0xcd; 32]).expect("32 bytes, within curve order");
 /// let public_key = PublicKey::from_secret_key(&secp, &secret_key);
 /// # }
 /// ```
@@ -168,9 +168,13 @@ impl str::FromStr for PublicKey {
     fn from_str(s: &str) -> Result<PublicKey, Error> {
         let mut res = [0u8; constants::UNCOMPRESSED_PUBLIC_KEY_SIZE];
         match from_hex(s, &mut res) {
-            Ok(constants::PUBLIC_KEY_SIZE) =>
-                PublicKey::from_slice(&res[0..constants::PUBLIC_KEY_SIZE]),
-            Ok(constants::UNCOMPRESSED_PUBLIC_KEY_SIZE) => PublicKey::from_slice(&res),
+            Ok(constants::PUBLIC_KEY_SIZE) => {
+                let bytes: [u8; constants::PUBLIC_KEY_SIZE] =
+                    res[0..constants::PUBLIC_KEY_SIZE].try_into().unwrap();
+                PublicKey::from_byte_array_compressed(&bytes)
+            }
+            Ok(constants::UNCOMPRESSED_PUBLIC_KEY_SIZE) =>
+                PublicKey::from_byte_array_uncompressed(&res),
             _ => Err(Error::InvalidPublicKey),
         }
     }
@@ -211,6 +215,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.")]
     #[inline]
     pub fn from_slice(data: &[u8]) -> Result<SecretKey, Error> {
         match <[u8; constants::SECRET_KEY_SIZE]>::try_from(data) {
@@ -362,7 +367,7 @@ impl SecretKey {
 impl<T: ThirtyTwoByteHash> From<T> for SecretKey {
     /// Converts a 32-byte hash directly to a secret key without error paths.
     fn from(t: T) -> SecretKey {
-        SecretKey::from_slice(&t.into_32()).expect("failed to create secret key")
+        SecretKey::from_byte_array(&t.into_32()).expect("failed to create secret key")
     }
 }
 
@@ -542,7 +547,7 @@ impl PublicKey {
         };
         buf[1..].clone_from_slice(&pk.serialize());
 
-        PublicKey::from_slice(&buf).expect("we know the buffer is valid")
+        PublicKey::from_byte_array_compressed(&buf).expect("we know the buffer is valid")
     }
 
     #[inline]
@@ -1156,8 +1161,7 @@ impl str::FromStr for XOnlyPublicKey {
     fn from_str(s: &str) -> Result<XOnlyPublicKey, Error> {
         let mut res = [0u8; constants::SCHNORR_PUBLIC_KEY_SIZE];
         match from_hex(s, &mut res) {
-            Ok(constants::SCHNORR_PUBLIC_KEY_SIZE) =>
-                XOnlyPublicKey::from_slice(&res[0..constants::SCHNORR_PUBLIC_KEY_SIZE]),
+            Ok(constants::SCHNORR_PUBLIC_KEY_SIZE) => XOnlyPublicKey::from_byte_array(&res),
             _ => Err(Error::InvalidPublicKey),
         }
     }
@@ -1203,6 +1207,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.")]
     #[inline]
     pub fn from_slice(data: &[u8]) -> Result<XOnlyPublicKey, Error> {
         match <[u8; constants::SCHNORR_PUBLIC_KEY_SIZE]>::try_from(data) {

src/schnorr.rs

@@ -78,6 +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.")]
     #[inline]
     pub fn from_slice(data: &[u8]) -> Result<Signature, Error> {
         match data.len() {