bitcoin: Remove rand deprecated stuff

Use the new `rand` API exposed by recent update of `secp`.

Author: tcharding

bitcoin/examples/create-p2wpkh-address.rs

@@ -8,7 +8,7 @@ fn main() {
     let secp = Secp256k1::new();
 
     // Generate secp256k1 public and private key pair.
-    let (secret_key, public_key) = secp.generate_keypair(&mut rand::thread_rng());
+    let (secret_key, public_key) = secp.generate_keypair(&mut rand::rng());
 
     // Create a Bitcoin private key to be used on the Bitcoin mainnet.
     let private_key = PrivateKey::new(secret_key, Network::Bitcoin);

bitcoin/examples/sign-tx-segwit-v0.rs

@@ -88,7 +88,7 @@ fn main() {
 ///
 /// In a real application these would be actual secrets.
 fn senders_keys<C: Signing>(secp: &Secp256k1<C>) -> (SecretKey, WPubkeyHash) {
-    let sk = SecretKey::new(&mut rand::thread_rng());
+    let sk = SecretKey::new(&mut rand::rng());
     let pk = bitcoin::PublicKey::new(sk.public_key(secp));
     let wpkh = pk.wpubkey_hash().expect("key is compressed");
 

bitcoin/examples/sign-tx-taproot.rs

@@ -86,7 +86,7 @@ fn main() {
 ///
 /// In a real application these would be actual secrets.
 fn senders_keys<C: Signing>(secp: &Secp256k1<C>) -> Keypair {
-    let sk = SecretKey::new(&mut rand::thread_rng());
+    let sk = SecretKey::new(&mut rand::rng());
     Keypair::from_secret_key(secp, &sk)
 }
 

bitcoin/src/consensus/encode.rs

@@ -988,20 +988,20 @@ mod tests {
     #[test]
     #[cfg(feature = "rand-std")]
     fn serialization_round_trips() {
-        use secp256k1::rand::{thread_rng, Rng};
+        use secp256k1::rand::{self, Rng};
 
         macro_rules! round_trip {
             ($($val_type:ty),*) => {
                 $(
-                    let r: $val_type = thread_rng().gen();
+                    let r: $val_type = rand::rng().random();
                     assert_eq!(deserialize::<$val_type>(&serialize(&r)).unwrap(), r);
                 )*
             };
         }
         macro_rules! round_trip_bytes {
             ($(($val_type:ty, $data:expr)),*) => {
                 $(
-                    thread_rng().fill(&mut $data[..]);
+                    rand::rng().fill(&mut $data[..]);
                     assert_eq!(deserialize::<$val_type>(&serialize(&$data)).unwrap()[..], $data[..]);
                 )*
             };
@@ -1016,7 +1016,7 @@ mod tests {
 
             data.clear();
             data64.clear();
-            let len = thread_rng().gen_range(1..256);
+            let len = rand::rng().random_range(1..256);
             data.resize(len, 0u8);
             data64.resize(len, 0u64);
             let mut arr33 = [0u8; 33];

bitcoin/src/crypto/key.rs

@@ -544,7 +544,7 @@ impl PrivateKey {
     /// a secure random number generator.
     #[cfg(feature = "rand-std")]
     pub fn generate(network: impl Into<NetworkKind>) -> PrivateKey {
-        let secret_key = secp256k1::SecretKey::new(&mut rand::thread_rng());
+        let secret_key = secp256k1::SecretKey::new(&mut secp256k1::rand::rng());
         PrivateKey::new(secret_key, network.into())
     }
     /// Constructs a new compressed ECDSA private key from the provided generic Secp256k1 private key
@@ -1759,7 +1759,7 @@ mod tests {
         use secp256k1::rand;
 
         let secp = Secp256k1::new();
-        let kp = Keypair::new(&secp, &mut rand::thread_rng());
+        let kp = Keypair::new(&secp, &mut rand::rng());
 
         let _ = PublicKey::new(kp);
         let _ = PublicKey::new_uncompressed(kp);

bitcoin/src/merkle_tree/block.rs

@@ -576,7 +576,7 @@ mod tests {
 
     #[cfg(feature = "rand-std")]
     fn pmt_test(tx_count: usize) {
-        let mut rng = secp256k1::rand::thread_rng();
+        let mut rng = secp256k1::rand::rng();
         // Create some fake tx ids
         let tx_ids = (1..=tx_count)
             .map(|i| format!("{:064x}", i).parse::<Txid>().unwrap())
@@ -600,7 +600,7 @@ mod tests {
                 // Generate `att / 2` random bits
                 let rand_bits = match att / 2 {
                     0 => 0,
-                    bits => rng.gen::<u64>() >> (64 - bits),
+                    bits => rng.random::<u64>() >> (64 - bits),
                 };
                 let include = rand_bits == 0;
                 matches[j] = include;
@@ -748,8 +748,8 @@ mod tests {
     impl PartialMerkleTree {
         /// Flip one bit in one of the hashes - this should break the authentication
         fn damage(&mut self, rng: &mut ThreadRng) {
-            let n = rng.gen_range(0..self.hashes.len());
-            let bit = rng.gen::<u8>();
+            let n = rng.random_range(0..self.hashes.len());
+            let bit = rng.random::<u8>();
             let hashes = &mut self.hashes;
             let mut hash = hashes[n].to_byte_array();
             hash[(bit >> 3) as usize] ^= 1 << (bit & 7);

bitcoin/src/psbt/mod.rs

@@ -2369,11 +2369,11 @@ mod tests {
 
     #[cfg(feature = "rand-std")]
     fn gen_keys() -> (PrivateKey, PublicKey, Secp256k1<All>) {
-        use secp256k1::rand::thread_rng;
+        use secp256k1::rand;
 
         let secp = Secp256k1::new();
 
-        let sk = SecretKey::new(&mut thread_rng());
+        let sk = SecretKey::new(&mut rand::rng());
         let priv_key = PrivateKey::new(sk, NetworkKind::Test);
         let pk = PublicKey::from_private_key(&secp, priv_key);
 

bitcoin/src/sign_message.rs

@@ -252,7 +252,7 @@ mod tests {
         let message = "rust-bitcoin MessageSignature test";
         let msg_hash = super::signed_msg_hash(message);
         let msg = secp256k1::Message::from_digest(msg_hash.to_byte_array());
-        let privkey = secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng());
+        let privkey = secp256k1::SecretKey::new(&mut secp256k1::rand::rng());
         let secp_sig = secp.sign_ecdsa_recoverable(msg, &privkey);
         let signature = super::MessageSignature { signature: secp_sig, compressed: true };