From 87d936a765cb0b67d795fa4f84a900f7bece2a89 Mon Sep 17 00:00:00 2001 From: Thomas Eizinger Date: Thu, 9 Sep 2021 19:37:31 +1000 Subject: [PATCH] Rename `schnorr::PublicKey` to `schnorr::XOnlyPublicKey` The public key is unrelated to the signature algorithm. It will be moved out of the module in another commit. For ease of review, the renamed is kept separate. --- src/schnorrsig.rs | 102 +++++++++++++++++++++++----------------------- 1 file changed, 51 insertions(+), 51 deletions(-) diff --git a/src/schnorrsig.rs b/src/schnorrsig.rs index 00de83d..62d90d8 100644 --- a/src/schnorrsig.rs +++ b/src/schnorrsig.rs @@ -74,11 +74,11 @@ impl str::FromStr for Signature { } } -/// A Schnorr public key, used for verification of Schnorr signatures +/// A x-only public key, used for verification of Schnorr signatures #[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)] -pub struct PublicKey(ffi::XOnlyPublicKey); +pub struct XOnlyPublicKey(ffi::XOnlyPublicKey); -impl fmt::LowerHex for PublicKey { +impl fmt::LowerHex for XOnlyPublicKey { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let ser = self.serialize(); for ch in &ser[..] { @@ -88,19 +88,19 @@ impl fmt::LowerHex for PublicKey { } } -impl fmt::Display for PublicKey { +impl fmt::Display for XOnlyPublicKey { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(self, f) } } -impl str::FromStr for PublicKey { +impl str::FromStr for XOnlyPublicKey { type Err = Error; - fn from_str(s: &str) -> Result { + fn from_str(s: &str) -> Result { let mut res = [0u8; constants::SCHNORRSIG_PUBLIC_KEY_SIZE]; match from_hex(s, &mut res) { Ok(constants::SCHNORRSIG_PUBLIC_KEY_SIZE) => { - PublicKey::from_slice(&res[0..constants::SCHNORRSIG_PUBLIC_KEY_SIZE]) + XOnlyPublicKey::from_slice(&res[0..constants::SCHNORRSIG_PUBLIC_KEY_SIZE]) } _ => Err(Error::InvalidPublicKey), } @@ -122,7 +122,7 @@ impl Signature { } } -impl PublicKey { +impl XOnlyPublicKey { /// Obtains a raw const pointer suitable for use with FFI functions #[inline] pub fn as_ptr(&self) -> *const ffi::XOnlyPublicKey { @@ -137,7 +137,7 @@ impl PublicKey { /// Creates a new Schnorr public key from a Schnorr key pair. #[inline] - pub fn from_keypair(secp: &Secp256k1, keypair: &KeyPair) -> PublicKey { + pub fn from_keypair(secp: &Secp256k1, keypair: &KeyPair) -> XOnlyPublicKey { let mut pk_parity = 0; unsafe { let mut xonly_pk = ffi::XOnlyPublicKey::new(); @@ -148,7 +148,7 @@ impl PublicKey { keypair.as_ptr(), ); debug_assert_eq!(ret, 1); - PublicKey(xonly_pk) + XOnlyPublicKey(xonly_pk) } } @@ -159,7 +159,7 @@ impl PublicKey { /// 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 #[inline] - pub fn from_slice(data: &[u8]) -> Result { + pub fn from_slice(data: &[u8]) -> Result { if data.is_empty() || data.len() != constants::SCHNORRSIG_PUBLIC_KEY_SIZE { return Err(Error::InvalidPublicKey); } @@ -172,7 +172,7 @@ impl PublicKey { data.as_c_ptr(), ) == 1 { - Ok(PublicKey(pk)) + Ok(XOnlyPublicKey(pk)) } else { Err(Error::InvalidPublicKey) } @@ -270,7 +270,7 @@ impl PublicKey { } } -impl CPtr for PublicKey { +impl CPtr for XOnlyPublicKey { type Target = ffi::XOnlyPublicKey; fn as_c_ptr(&self) -> *const Self::Target { self.as_ptr() @@ -282,15 +282,15 @@ impl CPtr for PublicKey { } /// Creates a new Schnorr public key from a FFI x-only public key -impl From for PublicKey { +impl From for XOnlyPublicKey { #[inline] - fn from(pk: ffi::XOnlyPublicKey) -> PublicKey { - PublicKey(pk) + fn from(pk: ffi::XOnlyPublicKey) -> XOnlyPublicKey { + XOnlyPublicKey(pk) } } -impl From<::key::PublicKey> for PublicKey { - fn from(src: ::key::PublicKey) -> PublicKey { +impl From<::key::PublicKey> for XOnlyPublicKey { + fn from(src: ::key::PublicKey) -> XOnlyPublicKey { unsafe { let mut pk = ffi::XOnlyPublicKey::new(); assert_eq!( @@ -302,13 +302,13 @@ impl From<::key::PublicKey> for PublicKey { src.as_c_ptr(), ) ); - PublicKey(pk) + XOnlyPublicKey(pk) } } } #[cfg(feature = "serde")] -impl ::serde::Serialize for PublicKey { +impl ::serde::Serialize for XOnlyPublicKey { fn serialize(&self, s: S) -> Result { if s.is_human_readable() { s.collect_str(self) @@ -319,7 +319,7 @@ impl ::serde::Serialize for PublicKey { } #[cfg(feature = "serde")] -impl<'de> ::serde::Deserialize<'de> for PublicKey { +impl<'de> ::serde::Deserialize<'de> for XOnlyPublicKey { fn deserialize>(d: D) -> Result { if d.is_human_readable() { d.deserialize_str(super::serde_util::FromStrVisitor::new( @@ -328,7 +328,7 @@ impl<'de> ::serde::Deserialize<'de> for PublicKey { } else { d.deserialize_bytes(super::serde_util::BytesVisitor::new( "raw 32 bytes schnorr public key", - PublicKey::from_slice + XOnlyPublicKey::from_slice )) } } @@ -411,7 +411,7 @@ impl Secp256k1 { &self, sig: &Signature, msg: &Message, - pubkey: &PublicKey, + pubkey: &XOnlyPublicKey, ) -> Result<(), Error> { unsafe { let ret = ffi::secp256k1_schnorrsig_verify( @@ -439,9 +439,9 @@ impl Secp256k1 { pub fn generate_schnorrsig_keypair( &self, rng: &mut R, - ) -> (KeyPair, PublicKey) { + ) -> (KeyPair, XOnlyPublicKey) { let sk = KeyPair::new(self, rng); - let pubkey = PublicKey::from_keypair(self, &sk); + let pubkey = XOnlyPublicKey::from_keypair(self, &sk); (sk, pubkey) } } @@ -450,7 +450,7 @@ impl Secp256k1 { mod tests { use super::super::Error::InvalidPublicKey; use super::super::{constants, from_hex, All, Message, Secp256k1}; - use super::{KeyPair, PublicKey, Signature}; + use super::{KeyPair, XOnlyPublicKey, Signature}; use rand::{rngs::ThreadRng, thread_rng, Error, ErrorKind, RngCore}; use rand_core::impls; use std::iter; @@ -548,7 +548,7 @@ mod tests { let msg = Message::from_slice(&hex_msg).unwrap(); let sig = Signature::from_str("6470FD1303DDA4FDA717B9837153C24A6EAB377183FC438F939E0ED2B620E9EE5077C4A8B8DCA28963D772A94F5F0DDF598E1C47C137F91933274C7C3EDADCE8").unwrap(); let pubkey = - PublicKey::from_str("B33CC9EDC096D0A83416964BD3C6247B8FECD256E4EFA7870D2C854BDEB33390") + XOnlyPublicKey::from_str("B33CC9EDC096D0A83416964BD3C6247B8FECD256E4EFA7870D2C854BDEB33390") .unwrap(); assert!(secp.schnorrsig_verify(&sig, &msg, &pubkey).is_ok()); @@ -556,9 +556,9 @@ mod tests { #[test] fn test_pubkey_from_slice() { - assert_eq!(PublicKey::from_slice(&[]), Err(InvalidPublicKey)); - assert_eq!(PublicKey::from_slice(&[1, 2, 3]), Err(InvalidPublicKey)); - let pk = PublicKey::from_slice(&[ + assert_eq!(XOnlyPublicKey::from_slice(&[]), Err(InvalidPublicKey)); + assert_eq!(XOnlyPublicKey::from_slice(&[1, 2, 3]), Err(InvalidPublicKey)); + let pk = XOnlyPublicKey::from_slice(&[ 0xB3, 0x3C, 0xC9, 0xED, 0xC0, 0x96, 0xD0, 0xA8, 0x34, 0x16, 0x96, 0x4B, 0xD3, 0xC6, 0x24, 0x7B, 0x8F, 0xEC, 0xD2, 0x56, 0xE4, 0xEF, 0xA7, 0x87, 0x0D, 0x2C, 0x85, 0x4B, 0xDE, 0xB3, 0x33, 0x90, @@ -571,7 +571,7 @@ mod tests { let secp = Secp256k1::new(); let (_, pubkey) = secp.generate_schnorrsig_keypair(&mut thread_rng()); let ser = pubkey.serialize(); - let pubkey2 = PublicKey::from_slice(&ser).unwrap(); + let pubkey2 = XOnlyPublicKey::from_slice(&ser).unwrap(); assert_eq!(pubkey, pubkey2); } @@ -584,35 +584,35 @@ mod tests { assert_eq!(SecretKey::from_str(sk_str).unwrap(), sk); let pk = ::key::PublicKey::from_keypair(&keypair); assert_eq!(::key::PublicKey::from_secret_key(&secp, &sk), pk); - let xpk = PublicKey::from_keypair(&secp, &keypair); - assert_eq!(PublicKey::from(pk), xpk); + let xpk = XOnlyPublicKey::from_keypair(&secp, &keypair); + assert_eq!(XOnlyPublicKey::from(pk), xpk); } #[test] fn test_pubkey_from_bad_slice() { // Bad sizes assert_eq!( - PublicKey::from_slice(&[0; constants::SCHNORRSIG_PUBLIC_KEY_SIZE - 1]), + XOnlyPublicKey::from_slice(&[0; constants::SCHNORRSIG_PUBLIC_KEY_SIZE - 1]), Err(InvalidPublicKey) ); assert_eq!( - PublicKey::from_slice(&[0; constants::SCHNORRSIG_PUBLIC_KEY_SIZE + 1]), + XOnlyPublicKey::from_slice(&[0; constants::SCHNORRSIG_PUBLIC_KEY_SIZE + 1]), Err(InvalidPublicKey) ); // Bad parse assert_eq!( - PublicKey::from_slice(&[0xff; constants::SCHNORRSIG_PUBLIC_KEY_SIZE]), + XOnlyPublicKey::from_slice(&[0xff; constants::SCHNORRSIG_PUBLIC_KEY_SIZE]), Err(InvalidPublicKey) ); // In fuzzing mode restrictions on public key validity are much more // relaxed, thus the invalid check below is expected to fail. #[cfg(not(fuzzing))] assert_eq!( - PublicKey::from_slice(&[0x55; constants::SCHNORRSIG_PUBLIC_KEY_SIZE]), + XOnlyPublicKey::from_slice(&[0x55; constants::SCHNORRSIG_PUBLIC_KEY_SIZE]), Err(InvalidPublicKey) ); - assert_eq!(PublicKey::from_slice(&[]), Err(InvalidPublicKey)); + assert_eq!(XOnlyPublicKey::from_slice(&[]), Err(InvalidPublicKey)); } #[test] @@ -630,43 +630,43 @@ mod tests { // In fuzzing mode secret->public key derivation is different, so // hard-code the epected result. #[cfg(not(fuzzing))] - let pk = PublicKey::from_keypair(&s, &sk); + let pk = XOnlyPublicKey::from_keypair(&s, &sk); #[cfg(fuzzing)] - let pk = PublicKey::from_slice(&[0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f, 0x1c, 0x97, 0x09, 0xe2, 0x30, 0x92, 0x06, 0x7d, 0x06, 0x83, 0x7f, 0x30, 0xaa, 0x0c, 0xd0, 0x54, 0x4a, 0xc8, 0x87, 0xfe, 0x91, 0xdd, 0xd1, 0x66]).expect("pk"); + let pk = XOnlyPublicKey::from_slice(&[0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f, 0x1c, 0x97, 0x09, 0xe2, 0x30, 0x92, 0x06, 0x7d, 0x06, 0x83, 0x7f, 0x30, 0xaa, 0x0c, 0xd0, 0x54, 0x4a, 0xc8, 0x87, 0xfe, 0x91, 0xdd, 0xd1, 0x66]).expect("pk"); assert_eq!( pk.to_string(), "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166" ); assert_eq!( - PublicKey::from_str("18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166") + XOnlyPublicKey::from_str("18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166") .unwrap(), pk ); - assert!(PublicKey::from_str( + assert!(XOnlyPublicKey::from_str( "00000000000000000000000000000000000000000000000000000000000000000" ) .is_err()); - assert!(PublicKey::from_str( + assert!(XOnlyPublicKey::from_str( "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd16601" ) .is_err()); - assert!(PublicKey::from_str( + assert!(XOnlyPublicKey::from_str( "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd16" ) .is_err()); - assert!(PublicKey::from_str( + assert!(XOnlyPublicKey::from_str( "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd1" ) .is_err()); - assert!(PublicKey::from_str( + assert!(XOnlyPublicKey::from_str( "xx18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd1" ) .is_err()); let long_str: String = iter::repeat('a').take(1024 * 1024).collect(); - assert!(PublicKey::from_str(&long_str).is_err()); + assert!(XOnlyPublicKey::from_str(&long_str).is_err()); } #[test] @@ -734,7 +734,7 @@ mod tests { static PK_STR: &'static str = "\ 18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166\ "; - let pk = PublicKey::from_slice(&PK_BYTES).unwrap(); + let pk = XOnlyPublicKey::from_slice(&PK_BYTES).unwrap(); assert_tokens(&sig.compact(), &[Token::BorrowedBytes(&SIG_BYTES[..])]); assert_tokens(&sig.compact(), &[Token::Bytes(&SIG_BYTES[..])]); @@ -763,7 +763,7 @@ mod tests { let orig_pk = pk; kp.tweak_add_assign(&s, &tweak).expect("Tweak error"); let parity = pk.tweak_add_assign(&s, &tweak).expect("Tweak error"); - assert_eq!(PublicKey::from_keypair(&s, &kp), pk); + assert_eq!(XOnlyPublicKey::from_keypair(&s, &kp), pk); assert!(orig_pk.tweak_add_check(&s, &pk, parity, tweak)); } } @@ -779,8 +779,8 @@ mod tests { ) .unwrap(); - let pk1 = PublicKey::from(kpk1); - let pk2 = PublicKey::from(kpk2); + let pk1 = XOnlyPublicKey::from(kpk1); + let pk2 = XOnlyPublicKey::from(kpk2); assert_eq!(pk1.serialize()[..], kpk1.serialize()[1..]); assert_eq!(pk2.serialize()[..], kpk2.serialize()[1..]);