feat: implement byte array conversions for XOnlyPublicKey

Adds `to_byte_array`, `from_byte_array`, and `try_from_byte_array` to
XOnlyPublicKey. The implementation wraps `secp256k1_xonly_pubkey_parse`
to ensure the provided x-coordinate represents a valid point on the curve.

The `from_byte_array` method uses a `debug_assert` to satisfy the
`bytes_rtt_test` macro requirements, while `try_from_byte_array`
provides a fallible interface for production use.

Author: Abeeujah

src/key/mod.rs

@@ -845,7 +845,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_byte_array(res),
+            Ok(constants::SCHNORR_PUBLIC_KEY_SIZE) => XOnlyPublicKey::try_from_byte_array(res),
             _ => Err(Error::InvalidPublicKey),
         }
     }
@@ -882,19 +882,34 @@ impl XOnlyPublicKey {
     #[inline]
     pub fn from_slice(data: &[u8]) -> Result<XOnlyPublicKey, Error> {
         match <[u8; constants::SCHNORR_PUBLIC_KEY_SIZE]>::try_from(data) {
-            Ok(data) => Self::from_byte_array(data),
+            Ok(data) => Self::try_from_byte_array(data),
             Err(_) => Err(InvalidPublicKey),
         }
     }
 
+    /// Creates a schnorr public key directly from a byte array.
+    #[inline]
+    pub fn from_byte_array(data: [u8; constants::SCHNORR_PUBLIC_KEY_SIZE]) -> XOnlyPublicKey {
+        unsafe {
+            let mut pk = ffi::XOnlyPublicKey::new();
+            let res = ffi::secp256k1_xonly_pubkey_parse(
+                ffi::secp256k1_context_no_precomp,
+                &mut pk,
+                data.as_c_ptr(),
+            );
+            debug_assert_eq!(res, 1);
+            XOnlyPublicKey(pk)
+        }
+    }
+
     /// Creates a schnorr public key directly from a byte array.
     ///
     /// # Errors
     ///
     /// Returns [`Error::InvalidPublicKey`] if the array does not represent a valid Secp256k1 point
     /// x coordinate.
     #[inline]
-    pub fn from_byte_array(
+    pub fn try_from_byte_array(
         data: [u8; constants::SCHNORR_PUBLIC_KEY_SIZE],
     ) -> Result<XOnlyPublicKey, Error> {
         unsafe {
@@ -912,6 +927,10 @@ impl XOnlyPublicKey {
         }
     }
 
+    /// Returns the byte array of an `XOnlyPublicKey`
+    #[inline]
+    pub fn to_byte_array(&self) -> [u8; constants::SCHNORR_PUBLIC_KEY_SIZE] { self.serialize() }
+
     #[inline]
     /// Serializes the key as a byte-encoded x coordinate value (32 bytes).
     pub fn serialize(&self) -> [u8; constants::SCHNORR_PUBLIC_KEY_SIZE] {
@@ -1255,7 +1274,7 @@ impl<'de> serde::Deserialize<'de> for XOnlyPublicKey {
         } else {
             let visitor = super::serde_util::Tuple32Visitor::new(
                 "raw 32 bytes schnorr public key",
-                XOnlyPublicKey::from_byte_array,
+                XOnlyPublicKey::try_from_byte_array,
             );
             d.deserialize_tuple(constants::SCHNORR_PUBLIC_KEY_SIZE, visitor)
         }
@@ -1348,7 +1367,7 @@ impl<'a> Arbitrary<'a> for XOnlyPublicKey {
             }
 
             u.fill_buffer(&mut bytes[..])?;
-            if let Ok(pk) = XOnlyPublicKey::from_byte_array(bytes) {
+            if let Ok(pk) = XOnlyPublicKey::try_from_byte_array(bytes) {
                 return Ok(pk);
             }
         }
@@ -1998,7 +2017,7 @@ mod test {
         let pk = PublicKey::from_slice(&pk_bytes).expect("failed to create pk from iterator");
         let kp = Keypair::from_secret_key(&sk);
         let xonly =
-            XOnlyPublicKey::from_byte_array(PK_BYTES).expect("failed to get xonly from slice");
+            XOnlyPublicKey::try_from_byte_array(PK_BYTES).expect("failed to get xonly from slice");
 
         (sk, pk, kp, xonly)
     }

src/schnorr.rs

@@ -388,7 +388,7 @@ mod tests {
         let (pk, _parity) = kp.x_only_public_key();
 
         let ser = pk.serialize();
-        let pubkey2 = XOnlyPublicKey::from_byte_array(ser).unwrap();
+        let pubkey2 = XOnlyPublicKey::try_from_byte_array(ser).unwrap();
         assert_eq!(pk, pubkey2);
     }
 
@@ -514,7 +514,7 @@ mod tests {
             170, 12, 208, 84, 74, 200, 135, 254, 145, 221, 209, 102,
         ];
         static PK_STR: &str = "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166";
-        let pk = XOnlyPublicKey::from_byte_array(PK_BYTES).unwrap();
+        let pk = XOnlyPublicKey::try_from_byte_array(PK_BYTES).unwrap();
 
         assert_tokens(&sig.compact(), &[Token::BorrowedBytes(&SIG_BYTES[..])]);
         assert_tokens(&sig.compact(), &[Token::Bytes(&SIG_BYTES[..])]);
@@ -733,7 +733,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_byte_array(public_key) {
+            let is_verified = if let Ok(pubkey) = XOnlyPublicKey::try_from_byte_array(public_key) {
                 verify(&sig, &message, &pubkey).is_ok()
             } else {
                 false

tests/api.rs

@@ -59,6 +59,7 @@ macro_rules! bytes_rtt_test {
 // FIXME ElligatorSwift should pass this
 // Scalar has to_be_bytes and to_le_bytes (and corresponding froms)
 bytes_rtt_test!(rtt_i, schnorr::Signature);
+bytes_rtt_test!(rtt_c, XOnlyPublicKey);
 
 macro_rules! secret_bytes_rtt_test {
     ($name: ident, $ty:ty) => {

tests/serde.rs

@@ -105,7 +105,7 @@ fn bincode_keypair() {
 
 #[test]
 fn bincode_x_only_public_key() {
-    let pk = XOnlyPublicKey::from_byte_array(XONLY_PK_BYTES)
+    let pk = XOnlyPublicKey::try_from_byte_array(XONLY_PK_BYTES)
         .expect("failed to create xonly pk from slice");
     let ser = bincode::serialize(&pk).unwrap();