From 9039ae7f9082657b3612741728ba267098422a66 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Sun, 22 Jun 2025 14:16:56 +0000 Subject: [PATCH 1/4] deprecations: replace all TBDs with 0.31.0 We accidentally released 0.30.0 and 0.31.0 with "future" deprecations. Most users will not see these since the lint for them is different from the normal deprecation warning (and it's undocumented except to say that we "should not use" future deprecations, even though it works and there is no alternative). Somewhat fortunately, in 0.30.x we messed up the deprecations and provided an inconsistent and weird API to replace the old functions. But because we messed up the deprecation messages, we can pretend we didn't do it and just mark the deprecations as having started in 0.31.x --- src/ecdh.rs | 2 +- src/key.rs | 6 +++--- src/lib.rs | 2 +- src/schnorr.rs | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/ecdh.rs b/src/ecdh.rs index d8bc7950e..b632f1efe 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 { match bytes.len() { diff --git a/src/key.rs b/src/key.rs index 6b1dcd645..9b5df9ca8 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 { match <[u8; constants::SECRET_KEY_SIZE]>::try_from(data) { @@ -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( secp: &Secp256k1, @@ -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 { match <[u8; constants::SCHNORR_PUBLIC_KEY_SIZE]>::try_from(data) { diff --git a/src/lib.rs b/src/lib.rs index 40dc490ad..35f9d514d 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 { Ok(Message::from_digest(digest.try_into().map_err(|_| Error::InvalidMessage)?)) } diff --git a/src/schnorr.rs b/src/schnorr.rs index 8c0305fd8..621c5d9e2 100644 --- a/src/schnorr.rs +++ b/src/schnorr.rs @@ -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 { 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. From 39feb3bac7e89434d4530932b58f4737497b6bdb Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Sun, 22 Jun 2025 15:14:51 +0000 Subject: [PATCH 2/4] update unit tests and examples to remove deprecated functions --- examples/sign_verify.rs | 6 +++--- examples/sign_verify_recovery.rs | 6 +++--- src/ecdh.rs | 4 ++-- src/ecdsa/recovery.rs | 24 ++++++++++----------- src/ellswift.rs | 14 ++++++------ src/key.rs | 37 +++++++++++++++++--------------- src/lib.rs | 10 ++++----- src/musig.rs | 6 ++---- src/schnorr.rs | 10 +++++---- tests/serde.rs | 6 +++--- 10 files changed, 64 insertions(+), 59 deletions(-) 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( pubkey: [u8; 33], ) -> Result { 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( seckey: [u8; 32], ) -> Result { 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( recovery_id: u8, ) -> Result { 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( seckey: [u8; 32], ) -> Result { 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 b632f1efe..4fd90b788 100644 --- a/src/ecdh.rs +++ b/src/ecdh.rs @@ -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/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 9b5df9ca8..3aef6302b 100644 --- a/src/key.rs +++ b/src/key.rs @@ -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) } } @@ -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 35f9d514d..ffc8038c1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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 { - 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 621c5d9e2..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), )) } } @@ -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); From 39fe6283473045b048232be35869559b22e99404 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Sun, 22 Jun 2025 15:37:00 +0000 Subject: [PATCH 3/4] clippy: fix PartialOrd impl of SerializedSignature We have duplicated funny logic in the PartialOrd and Ord impls of SerializedSignature. No need to duplicate: just have PartialOrd call into Ord. --- src/ecdsa/serialized_signature.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 for [u8] { impl PartialOrd for SerializedSignature { fn partial_cmp(&self, other: &SerializedSignature) -> Option { - Some((**self).cmp(&**other)) + Some(self.cmp(other)) } } From 2df6636e783f194cffd248faf62b6c4da17057b6 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 25 Jun 2025 03:18:35 +0000 Subject: [PATCH 4/4] bump version to 0.31.1 --- Cargo-minimal.lock | 2 +- Cargo-recent.lock | 2 +- Cargo.toml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) 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 ", "Andrew Poelstra " ] license = "CC0-1.0"