musig: move serialized data length constants

Author: Ademan

secp256k1-sys/src/lib.rs

@@ -1449,14 +1449,6 @@ pub const MUSIG_PUBNONCE_LEN: usize = 132;
 /// from all participants for the final signature computation.
 pub const MUSIG_AGGNONCE_LEN: usize = 132;
 
-/// Serialized length (in bytes) of the aggregated nonce.
-/// The serialized form is used for transmitting or storing the aggregated nonce.
-pub const MUSIG_AGGNONCE_SERIALIZED_LEN: usize = 66;
-
-/// Serialized length (in bytes) of an individual public nonce.
-/// The serialized form is used for transmission between signers.
-pub const MUSIG_PUBNONCE_SERIALIZED_LEN: usize = 66;
-
 /// Length (in bytes) of the session structure.
 /// The session object holds all state needed for a MuSig2 signing session (e.g. aggregated nonce,
 /// key aggregation info, and other state necessary for computing partial signatures).
@@ -1466,11 +1458,6 @@ pub const MUSIG_SESSION_LEN: usize = 133;
 /// This structure include magic bytes ([0xeb, 0xfb, 0x1a, 0x32]) alongside the actual signature scalar.
 pub const MUSIG_PART_SIG_LEN: usize = 36;
 
-/// Serialized length (in bytes) of a partial signature.
-/// The serialized form is used for transmitting partial signatures to be
-/// aggregated into the final signature.
-pub const MUSIG_PART_SIG_SERIALIZED_LEN: usize = 32;
-
 #[repr(C)]
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct MusigKeyAggCache([c_uchar; MUSIG_KEYAGG_LEN]);

src/musig.rs

@@ -17,6 +17,19 @@ use crate::{
     Verification, XOnlyPublicKey,
 };
 
+/// Serialized length (in bytes) of the aggregated nonce.
+/// The serialized form is used for transmitting or storing the aggregated nonce.
+pub const AGGNONCE_SERIALIZED_LEN: usize = 66;
+
+/// Serialized length (in bytes) of an individual public nonce.
+/// The serialized form is used for transmission between signers.
+pub const PUBNONCE_SERIALIZED_LEN: usize = 66;
+
+/// Serialized length (in bytes) of a partial signature.
+/// The serialized form is used for transmitting partial signatures to be
+/// aggregated into the final signature.
+pub const PART_SIG_SERIALIZED_LEN: usize = 32;
+
 /// Musig parsing errors
 #[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub enum ParseError {
@@ -244,9 +257,9 @@ impl fmt::Display for PartialSignature {
 impl core::str::FromStr for PartialSignature {
     type Err = ParseError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut res = [0u8; ffi::MUSIG_PART_SIG_SERIALIZED_LEN];
+        let mut res = [0u8; PART_SIG_SERIALIZED_LEN];
         match from_hex(s, &mut res) {
-            Ok(ffi::MUSIG_PART_SIG_SERIALIZED_LEN) => PartialSignature::from_byte_array(&res),
+            Ok(PART_SIG_SERIALIZED_LEN) => PartialSignature::from_byte_array(&res),
             _ => Err(ParseError::MalformedArg),
         }
     }
@@ -274,7 +287,7 @@ impl<'de> serde::Deserialize<'de> for PartialSignature {
             d.deserialize_bytes(super::serde_util::BytesVisitor::new(
                 "a raw MuSig2 partial signature",
                 |slice| {
-                    let bytes: &[u8; ffi::MUSIG_PART_SIG_SERIALIZED_LEN] =
+                    let bytes: &[u8; PART_SIG_SERIALIZED_LEN] =
                         slice.try_into().map_err(|_| ParseError::MalformedArg)?;
 
                     Self::from_byte_array(bytes)
@@ -286,8 +299,8 @@ impl<'de> serde::Deserialize<'de> for PartialSignature {
 
 impl PartialSignature {
     /// Serialize a PartialSignature as a byte array.
-    pub fn serialize(&self) -> [u8; ffi::MUSIG_PART_SIG_SERIALIZED_LEN] {
-        let mut data = MaybeUninit::<[u8; ffi::MUSIG_PART_SIG_SERIALIZED_LEN]>::uninit();
+    pub fn serialize(&self) -> [u8; PART_SIG_SERIALIZED_LEN] {
+        let mut data = MaybeUninit::<[u8; PART_SIG_SERIALIZED_LEN]>::uninit();
         unsafe {
             if ffi::secp256k1_musig_partial_sig_serialize(
                 ffi::secp256k1_context_no_precomp,
@@ -309,7 +322,7 @@ impl PartialSignature {
     ///
     /// - MalformedArg: If the signature [`PartialSignature`] is out of curve order
     pub fn from_byte_array(
-        data: &[u8; ffi::MUSIG_PART_SIG_SERIALIZED_LEN],
+        data: &[u8; PART_SIG_SERIALIZED_LEN],
     ) -> Result<Self, ParseError> {
         let mut partial_sig = MaybeUninit::<ffi::MusigPartialSignature>::uninit();
         unsafe {
@@ -714,9 +727,9 @@ impl fmt::Display for PublicNonce {
 impl core::str::FromStr for PublicNonce {
     type Err = ParseError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut res = [0u8; ffi::MUSIG_PUBNONCE_SERIALIZED_LEN];
+        let mut res = [0u8; PUBNONCE_SERIALIZED_LEN];
         match from_hex(s, &mut res) {
-            Ok(ffi::MUSIG_PUBNONCE_SERIALIZED_LEN) => PublicNonce::from_byte_array(&res),
+            Ok(PUBNONCE_SERIALIZED_LEN) => PublicNonce::from_byte_array(&res),
             _ => Err(ParseError::MalformedArg),
         }
     }
@@ -744,7 +757,7 @@ impl<'de> serde::Deserialize<'de> for PublicNonce {
             d.deserialize_bytes(super::serde_util::BytesVisitor::new(
                 "a raw MuSig2 public nonce",
                 |slice| {
-                    let bytes: &[u8; ffi::MUSIG_PUBNONCE_SERIALIZED_LEN] =
+                    let bytes: &[u8; PUBNONCE_SERIALIZED_LEN] =
                         slice.try_into().map_err(|_| ParseError::MalformedArg)?;
 
                     Self::from_byte_array(bytes)
@@ -756,8 +769,8 @@ impl<'de> serde::Deserialize<'de> for PublicNonce {
 
 impl PublicNonce {
     /// Serialize a PublicNonce
-    pub fn serialize(&self) -> [u8; ffi::MUSIG_PUBNONCE_SERIALIZED_LEN] {
-        let mut data = [0; ffi::MUSIG_PUBNONCE_SERIALIZED_LEN];
+    pub fn serialize(&self) -> [u8; PUBNONCE_SERIALIZED_LEN] {
+        let mut data = [0; PUBNONCE_SERIALIZED_LEN];
         unsafe {
             if ffi::secp256k1_musig_pubnonce_serialize(
                 ffi::secp256k1_context_no_precomp,
@@ -779,7 +792,7 @@ impl PublicNonce {
     ///
     /// - MalformedArg: If the [`PublicNonce`] is 132 bytes, but out of curve order
     pub fn from_byte_array(
-        data: &[u8; ffi::MUSIG_PUBNONCE_SERIALIZED_LEN],
+        data: &[u8; PUBNONCE_SERIALIZED_LEN],
     ) -> Result<Self, ParseError> {
         let mut pub_nonce = MaybeUninit::<ffi::MusigPubNonce>::uninit();
         unsafe {
@@ -831,9 +844,9 @@ impl fmt::Display for AggregatedNonce {
 impl core::str::FromStr for AggregatedNonce {
     type Err = ParseError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut res = [0u8; ffi::MUSIG_AGGNONCE_SERIALIZED_LEN];
+        let mut res = [0u8; AGGNONCE_SERIALIZED_LEN];
         match from_hex(s, &mut res) {
-            Ok(ffi::MUSIG_AGGNONCE_SERIALIZED_LEN) => AggregatedNonce::from_byte_array(&res),
+            Ok(AGGNONCE_SERIALIZED_LEN) => AggregatedNonce::from_byte_array(&res),
             _ => Err(ParseError::MalformedArg),
         }
     }
@@ -861,7 +874,7 @@ impl<'de> serde::Deserialize<'de> for AggregatedNonce {
             d.deserialize_bytes(super::serde_util::BytesVisitor::new(
                 "a raw MuSig2 aggregated nonce",
                 |slice| {
-                    let bytes: &[u8; ffi::MUSIG_AGGNONCE_SERIALIZED_LEN] =
+                    let bytes: &[u8; AGGNONCE_SERIALIZED_LEN] =
                         slice.try_into().map_err(|_| ParseError::MalformedArg)?;
 
                     Self::from_byte_array(bytes)
@@ -941,8 +954,8 @@ impl AggregatedNonce {
     }
 
     /// Serialize a AggregatedNonce into a 66 bytes array.
-    pub fn serialize(&self) -> [u8; ffi::MUSIG_AGGNONCE_SERIALIZED_LEN] {
-        let mut data = [0; ffi::MUSIG_AGGNONCE_SERIALIZED_LEN];
+    pub fn serialize(&self) -> [u8; AGGNONCE_SERIALIZED_LEN] {
+        let mut data = [0; AGGNONCE_SERIALIZED_LEN];
         unsafe {
             if ffi::secp256k1_musig_aggnonce_serialize(
                 ffi::secp256k1_context_no_precomp,
@@ -964,7 +977,7 @@ impl AggregatedNonce {
     ///
     /// - MalformedArg: If the byte slice is 66 bytes, but the [`AggregatedNonce`] is invalid
     pub fn from_byte_array(
-        data: &[u8; ffi::MUSIG_AGGNONCE_SERIALIZED_LEN],
+        data: &[u8; AGGNONCE_SERIALIZED_LEN],
     ) -> Result<Self, ParseError> {
         let mut aggnonce = MaybeUninit::<ffi::MusigAggNonce>::uninit();
         unsafe {