rename thread_rng() to rng()

Author: getong

Cargo.toml

@@ -37,7 +37,7 @@ global-context-less-secure = ["global-context"]
 secp256k1-sys = { version = "0.11.0", default-features = false, path = "./secp256k1-sys" }
 
 hashes = { package = "bitcoin_hashes", version = "0.16", default-features = false, optional = true }
-rand = { version = "0.9", default-features = false, optional = true }
+rand = { version = "0.9", default-features = false, features = ["thread_rng"], optional = true }
 serde = { version = "1.0.103", default-features = false, optional = true }
 
 [dev-dependencies]

examples/generate_keys.rs

@@ -4,7 +4,7 @@ use secp256k1::{PublicKey, Secp256k1, SecretKey};
 
 fn main() {
     let secp = Secp256k1::new();
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     // First option:
     let (seckey, pubkey) = secp.generate_keypair(&mut rng);
 

examples/sign_verify.rs

@@ -1,7 +1,7 @@
 extern crate hashes;
 extern crate secp256k1;
 
-use hashes::{sha256, Hash};
+use hashes::sha256;
 use secp256k1::{ecdsa, Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification};
 
 fn verify<C: Verification>(

examples/sign_verify_recovery.rs

@@ -1,7 +1,7 @@
 extern crate hashes;
 extern crate secp256k1;
 
-use hashes::{sha256, Hash};
+use hashes::sha256;
 use secp256k1::{ecdsa, Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification};
 
 fn recover<C: Verification>(

src/context.rs

@@ -33,7 +33,7 @@ pub mod global {
     /// ```
     /// # #[cfg(all(feature = "global-context", feature = "rand", feature = "std"))] {
     /// use secp256k1::{PublicKey, SECP256K1};
-    /// let _ = SECP256K1.generate_keypair(&mut rand::thread_rng());
+    /// let _ = SECP256K1.generate_keypair(&mut rand::rng());
     /// # }
     /// ```
     pub static SECP256K1: &GlobalContext = &GlobalContext { __private: () };
@@ -180,9 +180,9 @@ mod alloc_only {
         /// ```
         /// # #[cfg(all(feature = "rand", feature = "std"))] {
         /// # use secp256k1::Secp256k1;
-        /// # use secp256k1::rand::{thread_rng, RngCore};
+        /// # use secp256k1::rand::{rng, RngCore};
         /// let mut ctx = Secp256k1::new();
-        /// # let mut rng = thread_rng();
+        /// # let mut rng = rng();
         /// # let mut seed = [0u8; 32];
         /// # rng.fill_bytes(&mut seed);
         /// // let seed = <32 bytes of random data>
@@ -216,7 +216,7 @@ mod alloc_only {
                 not(feature = "global-context-less-secure")
             ))]
             {
-                ctx.randomize(&mut rand::thread_rng());
+                ctx.randomize(&mut rand::rng());
             }
 
             #[allow(clippy::let_and_return)] // as for unusted_mut

src/ecdh.rs

@@ -24,8 +24,8 @@ const SHARED_SECRET_SIZE: usize = constants::SECRET_KEY_SIZE;
 /// # use secp256k1::{rand, Secp256k1};
 /// # use secp256k1::ecdh::SharedSecret;
 /// let s = Secp256k1::new();
-/// let (sk1, pk1) = s.generate_keypair(&mut rand::thread_rng());
-/// let (sk2, pk2) = s.generate_keypair(&mut rand::thread_rng());
+/// let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
+/// let (sk2, pk2) = s.generate_keypair(&mut rand::rng());
 /// let sec1 = SharedSecret::new(&pk2, &sk1);
 /// let sec2 = SharedSecret::new(&pk1, &sk2);
 /// assert_eq!(sec1, sec2);
@@ -116,8 +116,8 @@ impl AsRef<[u8]> for SharedSecret {
 /// # use secp256k1::hashes::{Hash, sha512};
 ///
 /// let s = Secp256k1::new();
-/// let (sk1, pk1) = s.generate_keypair(&mut rand::thread_rng());
-/// let (sk2, pk2) = s.generate_keypair(&mut rand::thread_rng());
+/// let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
+/// let (sk2, pk2) = s.generate_keypair(&mut rand::rng());
 ///
 /// let point1 = ecdh::shared_secret_point(&pk2, &sk1);
 /// let secret1 = sha512::Hash::hash(&point1);
@@ -197,8 +197,8 @@ mod tests {
     #[cfg(all(feature = "rand", feature = "std"))]
     fn ecdh() {
         let s = Secp256k1::signing_only();
-        let (sk1, pk1) = s.generate_keypair(&mut rand::thread_rng());
-        let (sk2, pk2) = s.generate_keypair(&mut rand::thread_rng());
+        let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
+        let (sk2, pk2) = s.generate_keypair(&mut rand::rng());
 
         let sec1 = SharedSecret::new(&pk2, &sk1);
         let sec2 = SharedSecret::new(&pk1, &sk2);
@@ -233,8 +233,8 @@ mod tests {
         use crate::ecdh::shared_secret_point;
 
         let s = Secp256k1::signing_only();
-        let (sk1, _) = s.generate_keypair(&mut rand::thread_rng());
-        let (_, pk2) = s.generate_keypair(&mut rand::thread_rng());
+        let (sk1, _) = s.generate_keypair(&mut rand::rng());
+        let (_, pk2) = s.generate_keypair(&mut rand::rng());
 
         let secret_sys = SharedSecret::new(&pk2, &sk1);
 
@@ -286,7 +286,7 @@ mod benches {
     #[bench]
     pub fn bench_ecdh(bh: &mut Bencher) {
         let s = Secp256k1::signing_only();
-        let (sk, pk) = s.generate_keypair(&mut rand::thread_rng());
+        let (sk, pk) = s.generate_keypair(&mut rand::rng());
 
         bh.iter(|| {
             let res = SharedSecret::new(&pk, &sk);

src/ecdsa/mod.rs

@@ -371,7 +371,7 @@ impl<C: Verification> Secp256k1<C> {
     /// # use secp256k1::{rand, Secp256k1, Message, Error};
     /// #
     /// # let secp = Secp256k1::new();
-    /// # let (secret_key, public_key) = secp.generate_keypair(&mut rand::thread_rng());
+    /// # let (secret_key, public_key) = secp.generate_keypair(&mut rand::rng());
     /// #
     /// let message = Message::from_digest_slice(&[0xab; 32]).expect("32 bytes");
     /// let sig = secp.sign_ecdsa(message, &secret_key);

src/ecdsa/recovery.rs

@@ -260,11 +260,11 @@ mod tests {
         let vrfy = Secp256k1::verification_only();
         let full = Secp256k1::new();
 
-        let msg = crate::random_32_bytes(&mut rand::thread_rng());
+        let msg = crate::random_32_bytes(&mut rand::rng());
         let msg = Message::from_digest_slice(&msg).unwrap();
 
         // Try key generation
-        let (sk, pk) = full.generate_keypair(&mut rand::thread_rng());
+        let (sk, pk) = full.generate_keypair(&mut rand::rng());
 
         // Try signing
         assert_eq!(sign.sign_ecdsa_recoverable(msg, &sk), full.sign_ecdsa_recoverable(msg, &sk));
@@ -290,7 +290,7 @@ mod tests {
     #[rustfmt::skip]
     fn sign() {
         let mut s = Secp256k1::new();
-        s.randomize(&mut rand::thread_rng());
+        s.randomize(&mut rand::rng());
 
         let sk = SecretKey::from_slice(&ONE).unwrap();
         let msg = Message::from_digest_slice(&ONE).unwrap();
@@ -315,7 +315,7 @@ mod tests {
     #[rustfmt::skip]
     fn sign_with_noncedata() {
         let mut s = Secp256k1::new();
-        s.randomize(&mut rand::thread_rng());
+        s.randomize(&mut rand::rng());
 
         let sk = SecretKey::from_slice(&ONE).unwrap();
         let msg = Message::from_digest_slice(&ONE).unwrap();
@@ -339,17 +339,17 @@ mod tests {
     #[cfg(all(feature = "rand", feature = "std"))]
     fn sign_and_verify_fail() {
         let mut s = Secp256k1::new();
-        s.randomize(&mut rand::thread_rng());
+        s.randomize(&mut rand::rng());
 
-        let msg = crate::random_32_bytes(&mut rand::thread_rng());
+        let msg = crate::random_32_bytes(&mut rand::rng());
         let msg = Message::from_digest_slice(&msg).unwrap();
 
-        let (sk, pk) = s.generate_keypair(&mut rand::thread_rng());
+        let (sk, pk) = s.generate_keypair(&mut rand::rng());
 
         let sigr = s.sign_ecdsa_recoverable(msg, &sk);
         let sig = sigr.to_standard();
 
-        let msg = crate::random_32_bytes(&mut rand::thread_rng());
+        let msg = crate::random_32_bytes(&mut rand::rng());
         let msg = Message::from_digest_slice(&msg).unwrap();
         assert_eq!(s.verify_ecdsa(msg, &sig, &pk), Err(Error::IncorrectSignature));
 
@@ -361,12 +361,12 @@ mod tests {
     #[cfg(all(feature = "rand", feature = "std"))]
     fn sign_with_recovery() {
         let mut s = Secp256k1::new();
-        s.randomize(&mut rand::thread_rng());
+        s.randomize(&mut rand::rng());
 
-        let msg = crate::random_32_bytes(&mut rand::thread_rng());
+        let msg = crate::random_32_bytes(&mut rand::rng());
         let msg = Message::from_digest_slice(&msg).unwrap();
 
-        let (sk, pk) = s.generate_keypair(&mut rand::thread_rng());
+        let (sk, pk) = s.generate_keypair(&mut rand::rng());
 
         let sig = s.sign_ecdsa_recoverable(msg, &sk);
 
@@ -377,14 +377,14 @@ mod tests {
     #[cfg(all(feature = "rand", feature = "std"))]
     fn sign_with_recovery_and_noncedata() {
         let mut s = Secp256k1::new();
-        s.randomize(&mut rand::thread_rng());
+        s.randomize(&mut rand::rng());
 
-        let msg = crate::random_32_bytes(&mut rand::thread_rng());
+        let msg = crate::random_32_bytes(&mut rand::rng());
         let msg = Message::from_digest_slice(&msg).unwrap();
 
         let noncedata = [42u8; 32];
 
-        let (sk, pk) = s.generate_keypair(&mut rand::thread_rng());
+        let (sk, pk) = s.generate_keypair(&mut rand::rng());
 
         let sig = s.sign_ecdsa_recoverable_with_noncedata(msg, &sk, &noncedata);
 
@@ -395,7 +395,7 @@ mod tests {
     #[cfg(all(feature = "rand", feature = "std"))]
     fn bad_recovery() {
         let mut s = Secp256k1::new();
-        s.randomize(&mut rand::thread_rng());
+        s.randomize(&mut rand::rng());
 
         let msg = Message::from_digest_slice(&[0x55; 32]).unwrap();
 
@@ -467,9 +467,9 @@ mod benches {
     #[bench]
     pub fn bench_recover(bh: &mut Bencher) {
         let s = Secp256k1::new();
-        let msg = crate::random_32_bytes(&mut rand::thread_rng());
+        let msg = crate::random_32_bytes(&mut rand::rng());
         let msg = Message::from_digest_slice(&msg).unwrap();
-        let (sk, _) = s.generate_keypair(&mut rand::thread_rng());
+        let (sk, _) = s.generate_keypair(&mut rand::rng());
         let sig = s.sign_ecdsa_recoverable(&msg, &sk);
 
         bh.iter(|| {