chore(ledger): switch to rand=0.9.2 and rand_chacha=0.9.0 (#9033)

* chore(ledger): switch to rand=0.9.2 and rand_chacha=0.9.0

* fix: pin rand=0.9.5 and rand_chacha=0.3.1 for leader schedule

Cargo.lock

@@ -9107,7 +9107,9 @@ dependencies = [
  "prost",
  "qualifier_attr",
  "rand 0.8.5",
+ "rand 0.9.2",
  "rand_chacha 0.3.1",
+ "rand_chacha 0.9.0",
  "rayon",
  "reed-solomon-erasure",
  "rocksdb",

dev-bins/Cargo.lock

@@ -7621,7 +7621,9 @@ dependencies = [
  "prost",
  "qualifier_attr",
  "rand 0.8.5",
+ "rand 0.9.2",
  "rand_chacha 0.3.1",
+ "rand_chacha 0.9.0",
  "rayon",
  "reed-solomon-erasure",
  "rocksdb",

ledger/Cargo.toml

@@ -51,8 +51,10 @@ num_cpus = { workspace = true }
 num_enum = { workspace = true }
 prost = { workspace = true }
 qualifier_attr = { workspace = true }
-rand = { workspace = true }
-rand_chacha = { workspace = true }
+rand = "0.9.2"
+rand0-8-5 = { package = "rand", version = "0.8.5" }
+rand_chacha = "0.9.0"
+rand_chacha0-3-1 = { package = "rand_chacha", version = "0.3.1" }
 rayon = { workspace = true }
 reed-solomon-erasure = { workspace = true, features = ["simd-accel"] }
 scopeguard = { workspace = true }

ledger/benches/blockstore.rs

@@ -91,10 +91,10 @@ fn bench_read_sequential(bench: &mut Bencher) {
     setup_read_bench(&blockstore, num_small_shreds, num_large_shreds, slot);
 
     let num_reads = total_shreds / 15;
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     bench.iter(move || {
         // Generate random starting point in the range [0, total_shreds - 1], read num_reads shreds sequentially
-        let start_index = rng.gen_range(0..num_small_shreds + num_large_shreds);
+        let start_index = rng.random_range(0..num_small_shreds + num_large_shreds);
         for i in start_index..start_index + num_reads {
             let _ = blockstore.get_data_shred(slot, i % total_shreds);
         }
@@ -119,9 +119,9 @@ fn bench_read_random(bench: &mut Bencher) {
 
     // Generate a num_reads sized random sample of indexes in range [0, total_shreds - 1],
     // simulating random reads
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     let indexes: Vec<usize> = (0..num_reads)
-        .map(|_| rng.gen_range(0..total_shreds) as usize)
+        .map(|_| rng.random_range(0..total_shreds) as usize)
         .collect();
     bench.iter(move || {
         for i in indexes.iter() {

ledger/benches/make_shreds_from_entries.rs

@@ -13,20 +13,20 @@ use {
 };
 
 fn make_dummy_hash<R: Rng>(rng: &mut R) -> Hash {
-    Hash::from(rng.gen::<[u8; 32]>())
+    Hash::from(rng.random::<[u8; 32]>())
 }
 
 fn make_dummy_transaction<R: Rng>(rng: &mut R) -> Transaction {
     solana_system_transaction::transfer(
-        &Keypair::new(),                      // from
-        &Pubkey::from(rng.gen::<[u8; 32]>()), // to
-        rng.gen(),                            // lamports
-        make_dummy_hash(rng),                 // recent_blockhash
+        &Keypair::new(),                         // from
+        &Pubkey::from(rng.random::<[u8; 32]>()), // to
+        rng.random(),                            // lamports
+        make_dummy_hash(rng),                    // recent_blockhash
     )
 }
 
 fn make_dummy_entry<R: Rng>(rng: &mut R) -> Entry {
-    let count = rng.gen_range(1..20);
+    let count = rng.random_range(1..20);
     let transactions = repeat_with(|| make_dummy_transaction(rng))
         .take(count)
         .collect();
@@ -62,8 +62,8 @@ fn make_shreds_from_entries<R: Rng>(
         entries,
         is_last_in_slot,
         chained_merkle_root,
-        rng.gen_range(0..2_000), // next_shred_index
-        rng.gen_range(0..2_000), // next_code_index
+        rng.random_range(0..2_000), // next_shred_index
+        rng.random_range(0..2_000), // next_code_index
         reed_solomon_cache,
         stats,
     );
@@ -76,14 +76,14 @@ fn run_make_shreds_from_entries(
     num_packets: usize,
     is_last_in_slot: bool,
 ) {
-    let mut rng = rand::thread_rng();
-    let slot = 315_892_061 + rng.gen_range(0..=100_000);
-    let parent_offset = rng.gen_range(1..=u16::MAX);
+    let mut rng = rand::rng();
+    let slot = 315_892_061 + rng.random_range(0..=100_000);
+    let parent_offset = rng.random_range(1..=u16::MAX);
     let shredder = Shredder::new(
         slot,
         slot - u64::from(parent_offset), // parent_slot
-        rng.gen_range(0..64),            // reference_tick
-        rng.gen(),                       // shred_version
+        rng.random_range(0..64),         // reference_tick
+        rng.random(),                    // shred_version
     )
     .unwrap();
     let keypair = Keypair::new();
@@ -130,14 +130,14 @@ fn run_recover_shreds(
     num_code: usize,
     is_last_in_slot: bool,
 ) {
-    let mut rng = rand::thread_rng();
-    let slot = 315_892_061 + rng.gen_range(0..=100_000);
-    let parent_offset = rng.gen_range(1..=u16::MAX);
+    let mut rng = rand::rng();
+    let slot = 315_892_061 + rng.random_range(0..=100_000);
+    let parent_offset = rng.random_range(1..=u16::MAX);
     let shredder = Shredder::new(
         slot,
         slot - u64::from(parent_offset), // parent_slot
-        rng.gen_range(0..64),            // reference_tick
-        rng.gen(),                       // shred_version
+        rng.random_range(0..64),         // reference_tick
+        rng.random(),                    // shred_version
     )
     .unwrap();
     let keypair = Keypair::new();
@@ -167,11 +167,11 @@ fn run_recover_shreds(
         .collect();
     let num_code = num_code.min(code.len());
     for _ in 0..num_code.min(data.len()) {
-        let k = rng.gen_range(0..data.len());
+        let k = rng.random_range(0..data.len());
         data.remove(k);
     }
     for i in 0..num_code {
-        let j = rng.gen_range(i..code.len());
+        let j = rng.random_range(i..code.len());
         code.swap(i, j);
     }
     code.sort_unstable_by_key(|shred| shred.index());

ledger/src/blockstore.rs

@@ -2365,7 +2365,7 @@ impl Blockstore {
         let mut all_shreds = vec![];
         let mut slot_entries = vec![];
         let reed_solomon_cache = ReedSolomonCache::default();
-        let mut chained_merkle_root = Hash::new_from_array(rand::thread_rng().gen());
+        let mut chained_merkle_root = Hash::new_from_array(rand::rng().random());
         // Find all the entries for start_slot
         for entry in entries.into_iter() {
             if remaining_ticks_in_slot == 0 {
@@ -4827,7 +4827,7 @@ pub fn create_new_ledger(
         &entries,
         true, // is_last_in_slot
         // chained_merkle_root
-        Hash::new_from_array(rand::thread_rng().gen()),
+        Hash::new_from_array(rand::rng().random()),
         0, // next_shred_index
         0, // next_code_index
         &ReedSolomonCache::default(),
@@ -5059,9 +5059,9 @@ pub fn entries_to_test_shreds(
             &Keypair::new(),
             entries,
             is_full_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            0,                                              // next_shred_index,
-            0,                                              // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            0,                                          // next_shred_index,
+            0,                                          // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         )
@@ -5225,7 +5225,7 @@ pub mod tests {
         assert_matches::assert_matches,
         bincode::{serialize, Options},
         crossbeam_channel::unbounded,
-        rand::{seq::SliceRandom, thread_rng},
+        rand::{rng, seq::SliceRandom},
         solana_account_decoder::parse_token::UiTokenAmount,
         solana_clock::{DEFAULT_MS_PER_SLOT, DEFAULT_TICKS_PER_SLOT},
         solana_entry::entry::{next_entry, next_entry_mut},
@@ -5687,14 +5687,14 @@ pub mod tests {
     fn test_index_fallback_deserialize() {
         let ledger_path = get_tmp_ledger_path_auto_delete!();
         let blockstore = Blockstore::open(ledger_path.path()).unwrap();
-        let mut rng = rand::thread_rng();
-        let slot = rng.gen_range(0..100);
+        let mut rng = rand::rng();
+        let slot = rng.random_range(0..100);
         let bincode = bincode::DefaultOptions::new()
             .reject_trailing_bytes()
             .with_fixint_encoding();
 
-        let data = 0..rng.gen_range(100..MAX_DATA_SHREDS_PER_SLOT as u64);
-        let coding = 0..rng.gen_range(100..MAX_DATA_SHREDS_PER_SLOT as u64);
+        let data = 0..rng.random_range(100..MAX_DATA_SHREDS_PER_SLOT as u64);
+        let coding = 0..rng.random_range(100..MAX_DATA_SHREDS_PER_SLOT as u64);
         let mut fallback = IndexFallback::new(slot);
         for (d, c) in data.clone().zip(coding.clone()) {
             fallback.data_mut().insert(d);
@@ -6025,7 +6025,7 @@ pub mod tests {
             .flatten()
             .collect();
 
-        all_shreds.shuffle(&mut thread_rng());
+        all_shreds.shuffle(&mut rng());
         blockstore.insert_shreds(all_shreds, None, false).unwrap();
         let mut result = recvr.try_recv().unwrap();
         result.sort_unstable();
@@ -10075,7 +10075,7 @@ pub mod tests {
             parent_slot,
             num_entries,
             fec_set_index,
-            Hash::new_from_array(rand::thread_rng().gen()),
+            Hash::new_from_array(rand::rng().random()),
         )
     }
 
@@ -10171,7 +10171,7 @@ pub mod tests {
         let leader_keypair = Arc::new(Keypair::new());
         let reed_solomon_cache = ReedSolomonCache::default();
         let shredder = Shredder::new(slot, 0, 0, 0).unwrap();
-        let merkle_root = Hash::new_from_array(rand::thread_rng().gen());
+        let merkle_root = Hash::new_from_array(rand::rng().random());
         let (shreds, _) = shredder.entries_to_merkle_shreds_for_tests(
             &leader_keypair,
             &entries1,
@@ -10531,7 +10531,7 @@ pub mod tests {
         let version = version_from_hash(&entries[0].hash);
         let shredder = Shredder::new(slot, 0, 0, version).unwrap();
         let reed_solomon_cache = ReedSolomonCache::default();
-        let merkle_root = Hash::new_from_array(rand::thread_rng().gen());
+        let merkle_root = Hash::new_from_array(rand::rng().random());
         let kp = Keypair::new();
         // produce normal shreds
         let (data1, coding1) = shredder.entries_to_merkle_shreds_for_tests(

ledger/src/blockstore/blockstore_purge.rs

@@ -998,7 +998,7 @@ pub mod tests {
             use rand::Rng;
 
             let mut key = [0u8; 64];
-            rand::thread_rng().fill(&mut key[..]);
+            rand::rng().fill(&mut key[..]);
             Signature::from(key)
         }
 

ledger/src/blockstore_meta.rs

@@ -889,7 +889,7 @@ mod test {
         super::*,
         bincode::Options,
         proptest::prelude::*,
-        rand::{seq::SliceRandom, thread_rng},
+        rand::{prelude::IndexedRandom as _, rng},
     };
 
     #[test]
@@ -912,7 +912,7 @@ mod test {
             config: erasure_config,
             first_received_coding_index: 0,
         };
-        let mut rng = thread_rng();
+        let mut rng = rng();
         let mut index = Index::new(0);
 
         let data_indexes = 0..erasure_config.num_data as u64;

ledger/src/blockstore_processor.rs

@@ -2324,7 +2324,7 @@ pub mod tests {
             },
         },
         assert_matches::assert_matches,
-        rand::{thread_rng, Rng},
+        rand::{rng, Rng},
         solana_account::{AccountSharedData, WritableAccount},
         solana_cost_model::transaction_cost::TransactionCost,
         solana_entry::entry::{create_ticks, next_entry, next_entry_mut},
@@ -4379,7 +4379,7 @@ pub mod tests {
             }
             i += 1;
 
-            let slot = bank.slot() + thread_rng().gen_range(1..3);
+            let slot = bank.slot() + rng().random_range(1..3);
             bank = Arc::new(Bank::new_from_parent(bank, &Pubkey::default(), slot));
         }
     }

ledger/src/leader_schedule.rs

@@ -1,6 +1,6 @@
 use {
-    rand::distributions::{Distribution, WeightedIndex},
-    rand_chacha::{rand_core::SeedableRng, ChaChaRng},
+    rand0_8_5::distributions::{Distribution, WeightedIndex},
+    rand_chacha0_3_1::{rand_core::SeedableRng, ChaChaRng},
     solana_clock::Epoch,
     solana_pubkey::Pubkey,
     std::{collections::HashMap, convert::identity, ops::Index, sync::Arc},
@@ -118,9 +118,9 @@ mod tests {
     #[test]
     fn test_get_leader_upcoming_slots() {
         const NUM_SLOTS: usize = 97;
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let pubkeys: Vec<_> = repeat_with(Pubkey::new_unique).take(4).collect();
-        let schedule: Vec<_> = repeat_with(|| pubkeys[rng.gen_range(0..3)])
+        let schedule: Vec<_> = repeat_with(|| pubkeys[rng.random_range(0..3)])
             .take(19)
             .collect();
         let schedule = IdentityKeyedLeaderSchedule::new_from_schedule(schedule);

ledger/src/shred.rs

@@ -967,11 +967,11 @@ mod tests {
         is_last_in_slot: bool,
     ) -> Result<Vec<merkle::Shred>, Error> {
         let thread_pool = ThreadPoolBuilder::new().num_threads(2).build().unwrap();
-        let chained_merkle_root = Hash::new_from_array(rng.gen());
-        let parent_offset = rng.gen_range(1..=u16::try_from(slot).unwrap_or(u16::MAX));
+        let chained_merkle_root = Hash::new_from_array(rng.random());
+        let parent_offset = rng.random_range(1..=u16::try_from(slot).unwrap_or(u16::MAX));
         let parent_slot = slot.checked_sub(u64::from(parent_offset)).unwrap();
         let mut data = vec![0u8; data_size];
-        let fec_set_index = rng.gen_range(0..21) * DATA_SHREDS_PER_FEC_BLOCK as u32;
+        let fec_set_index = rng.random_range(0..21) * DATA_SHREDS_PER_FEC_BLOCK as u32;
         rng.fill(&mut data[..]);
         merkle::make_shreds_from_data(
             &thread_pool,
@@ -980,8 +980,8 @@ mod tests {
             &data[..],
             slot,
             parent_slot,
-            rng.gen(),            // shred_version
-            rng.gen_range(1..64), // reference_tick
+            rng.random(),            // shred_version
+            rng.random_range(1..64), // reference_tick
             is_last_in_slot,
             fec_set_index, // next_shred_index
             fec_set_index, // next_code_index
@@ -1109,7 +1109,7 @@ mod tests {
     #[test_case(false ; "not_last_in_slot")]
     fn test_should_discard_shred(is_last_in_slot: bool) {
         agave_logger::setup();
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let slot = 18_291;
         let shreds = make_merkle_shreds_for_tests(
             &mut rng,
@@ -1125,8 +1125,8 @@ mod tests {
         let parent_slot = shreds[0].parent().unwrap();
         let shred_version = shreds[0].common_header().version;
 
-        let root = rng.gen_range(0..parent_slot);
-        let max_slot = slot + rng.gen_range(1..65536);
+        let root = rng.random_range(0..parent_slot);
+        let max_slot = slot + rng.random_range(1..65536);
         let mut packet = Packet::default();
 
         // Data shred sanity checks!
@@ -1373,7 +1373,7 @@ mod tests {
     #[test_case(false ; "do_not_enforce_fixed_fec_set")]
     fn test_should_discard_shred_fec_set_checks(enforce_fixed_fec_set: bool) {
         agave_logger::setup();
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let slot = 18_291;
         let shreds = make_merkle_shreds_for_tests(
             &mut rng,
@@ -1388,8 +1388,8 @@ mod tests {
         assert_matches!(shreds[0].shred_type(), ShredType::Data);
         let parent_slot = shreds[0].parent().unwrap();
         let shred_version = shreds[0].common_header().version;
-        let root = rng.gen_range(0..parent_slot);
-        let max_slot = slot + rng.gen_range(1..65536);
+        let root = rng.random_range(0..parent_slot);
+        let max_slot = slot + rng.random_range(1..65536);
 
         // fec_set_index not multiple of 32
         {
@@ -1495,7 +1495,7 @@ mod tests {
         let shreds: Vec<_> = shreds.into_iter().map(Shred::from).collect();
         let parent_slot = shreds[0].parent().unwrap();
         let shred_version = shreds[0].common_header().version;
-        let root = rng.gen_range(0..parent_slot);
+        let root = rng.random_range(0..parent_slot);
         let data_shreds: Vec<_> = shreds
             .iter()
             .filter(|s| s.shred_type() == ShredType::Data)
@@ -1664,7 +1664,7 @@ mod tests {
     #[test]
     fn test_shred_seed() {
         let mut rng = ChaChaRng::from_seed([147u8; 32]);
-        let leader = Pubkey::new_from_array(rng.gen());
+        let leader = Pubkey::new_from_array(rng.random());
         let key = ShredId(
             141939602, // slot
             28685,     // index
@@ -1674,7 +1674,7 @@ mod tests {
             bs58::encode(key.seed(&leader)).into_string(),
             "Gp4kUM4ZpWGQN5XSCyM9YHYWEBCAZLa94ZQuSgDE4r56"
         );
-        let leader = Pubkey::new_from_array(rng.gen());
+        let leader = Pubkey::new_from_array(rng.random());
         let key = ShredId(
             141945197, // slot
             23418,     // index
@@ -1913,8 +1913,8 @@ mod tests {
             Shred::new_from_serialized_shred(shred).unwrap()
         }
 
-        let mut rng = rand::thread_rng();
-        let slot = 285_376_049 + rng.gen_range(0..100_000);
+        let mut rng = rand::rng();
+        let slot = 285_376_049 + rng.random_range(0..100_000);
         let shreds: Vec<_> = make_merkle_shreds_for_tests(
             &mut rng,
             slot,
@@ -1967,7 +1967,7 @@ mod tests {
     #[test]
     fn test_data_complete_shred_index_validation() {
         agave_logger::setup();
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let slot = 18_291;
         let shreds = make_merkle_shreds_for_tests(
             &mut rng,
@@ -1985,8 +1985,8 @@ mod tests {
 
         let parent_slot = data_shred.parent().unwrap();
         let shred_version = data_shred.common_header().version;
-        let root = rng.gen_range(0..parent_slot);
-        let max_slot = slot + rng.gen_range(1..65536);
+        let root = rng.random_range(0..parent_slot);
+        let max_slot = slot + rng.random_range(1..65536);
 
         // Test case where DATA_COMPLETE_SHRED flag is set but index is not at expected position
         let mut packet = Packet::default();

ledger/src/shred/merkle.rs

@@ -1371,8 +1371,8 @@ mod test {
 
     #[test]
     fn test_merkle_proof_entry_from_hash() {
-        let mut rng = rand::thread_rng();
-        let bytes: [u8; 32] = rng.gen();
+        let mut rng = rand::rng();
+        let bytes: [u8; 32] = rng.random();
         let hash = Hash::from(bytes);
         let entry = &hash.as_ref()[..SIZE_OF_MERKLE_PROOF_ENTRY];
         let entry = MerkleProofEntry::try_from(entry).unwrap();
@@ -1381,8 +1381,8 @@ mod test {
 
     #[test]
     fn test_make_merkle_proof_error() {
-        let mut rng = rand::thread_rng();
-        let nodes = repeat_with(|| rng.gen::<[u8; 32]>()).map(Hash::from);
+        let mut rng = rand::rng();
+        let nodes = repeat_with(|| rng.random::<[u8; 32]>()).map(Hash::from);
         let nodes: Vec<_> = nodes.take(5).collect();
         let size = nodes.len();
         let tree = make_merkle_tree(nodes.into_iter().map(Ok)).unwrap();
@@ -1409,7 +1409,7 @@ mod test {
     #[test_case(73, false)]
     #[test_case(73, true)]
     fn test_recover_merkle_shreds(num_shreds: usize, resigned: bool) {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let reed_solomon_cache = ReedSolomonCache::default();
         for num_data_shreds in 1..num_shreds {
             let num_coding_shreds = num_shreds - num_data_shreds;
@@ -1442,13 +1442,13 @@ mod test {
             },
             slot: 145_865_705,
             index: 1835,
-            version: rng.gen(),
+            version: rng.random(),
             fec_set_index: 1835,
         };
         let data_header = {
-            let reference_tick = rng.gen_range(0..0x40);
+            let reference_tick = rng.random_range(0..0x40);
             DataShredHeader {
-                parent_offset: rng.gen::<u16>().max(1),
+                parent_offset: rng.random::<u16>().max(1),
                 flags: ShredFlags::from_bits_retain(reference_tick),
                 size: 0,
             }
@@ -1464,7 +1464,7 @@ mod test {
                 index: common_header.index + i as u32,
                 ..common_header
             };
-            let size = ShredData::SIZE_OF_HEADERS + rng.gen_range(0..capacity);
+            let size = ShredData::SIZE_OF_HEADERS + rng.random_range(0..capacity);
             let data_header = DataShredHeader {
                 size: size as u16,
                 ..data_header
@@ -1588,7 +1588,7 @@ mod test {
         [true, false]
     )]
     fn test_make_shreds_from_data(data_size: usize, is_last_in_slot: bool) {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let data_size = data_size.saturating_sub(16);
         let reed_solomon_cache = ReedSolomonCache::default();
         for data_size in data_size..data_size + 32 {
@@ -1599,10 +1599,10 @@ mod test {
     #[test_case(true)]
     #[test_case(false)]
     fn test_make_shreds_from_data_rand(is_last_in_slot: bool) {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let reed_solomon_cache = ReedSolomonCache::default();
         for _ in 0..32 {
-            let data_size = rng.gen_range(0..31200 * 7);
+            let data_size = rng.random_range(0..31200 * 7);
             run_make_shreds_from_data(&mut rng, data_size, is_last_in_slot, &reed_solomon_cache);
         }
     }
@@ -1611,7 +1611,7 @@ mod test {
     #[test_case(true)]
     #[test_case(false)]
     fn test_make_shreds_from_data_paranoid(is_last_in_slot: bool) {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let reed_solomon_cache = ReedSolomonCache::default();
         for data_size in 0..=PACKET_DATA_SIZE * 4 * 64 {
             run_make_shreds_from_data(&mut rng, data_size, is_last_in_slot, &reed_solomon_cache);
@@ -1626,13 +1626,13 @@ mod test {
     ) {
         let thread_pool = ThreadPoolBuilder::new().num_threads(2).build().unwrap();
         let keypair = Keypair::new();
-        let chained_merkle_root = Hash::new_from_array(rng.gen());
+        let chained_merkle_root = Hash::new_from_array(rng.random());
         let slot = 149_745_689;
-        let parent_slot = slot - rng.gen_range(1..65536);
-        let shred_version = rng.gen();
-        let reference_tick = rng.gen_range(1..64);
-        let next_shred_index = rng.gen_range(0..671);
-        let next_code_index = rng.gen_range(0..781);
+        let parent_slot = slot - rng.random_range(1..65536);
+        let shred_version = rng.random();
+        let reference_tick = rng.random_range(1..64);
+        let next_shred_index = rng.random_range(0..671);
+        let next_code_index = rng.random_range(0..781);
         let mut data = vec![0u8; data_size];
         rng.fill(&mut data[..]);
         let shreds = make_shreds_from_data(

ledger/src/shred/merkle_tree.rs

@@ -129,8 +129,8 @@ mod tests {
 
     #[test]
     fn test_merkle_proof_entry_from_hash() {
-        let mut rng = rand::thread_rng();
-        let bytes: [u8; 32] = rng.gen();
+        let mut rng = rand::rng();
+        let bytes: [u8; 32] = rng.random();
         let hash = Hash::from(bytes);
         let entry = &hash.as_ref()[..SIZE_OF_MERKLE_PROOF_ENTRY];
         let entry = MerkleProofEntry::try_from(entry).unwrap();
@@ -147,8 +147,8 @@ mod tests {
 
     #[test]
     fn test_make_merkle_proof_error() {
-        let mut rng = rand::thread_rng();
-        let nodes = repeat_with(|| rng.gen::<[u8; 32]>()).map(Hash::from);
+        let mut rng = rand::rng();
+        let nodes = repeat_with(|| rng.random::<[u8; 32]>()).map(Hash::from);
         let nodes: Vec<_> = nodes.take(5).collect();
         let size = nodes.len();
         let tree = make_merkle_tree(nodes.into_iter().map(Ok)).unwrap();
@@ -161,7 +161,7 @@ mod tests {
     }
 
     fn run_merkle_tree_round_trip<R: Rng>(rng: &mut R, size: usize) {
-        let nodes = repeat_with(|| rng.gen::<[u8; 32]>()).map(Hash::from);
+        let nodes = repeat_with(|| rng.random::<[u8; 32]>()).map(Hash::from);
         let nodes: Vec<_> = nodes.take(size).collect();
         let tree = make_merkle_tree(nodes.iter().cloned().map(Ok)).unwrap();
         let root = tree.last().copied().unwrap();
@@ -179,7 +179,7 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_round_trip_small() {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         for size in 1..=110 {
             run_merkle_tree_round_trip(&mut rng, size);
         }
@@ -187,7 +187,7 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_round_trip_big() {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         for size in 110..=143 {
             run_merkle_tree_round_trip(&mut rng, size);
         }

ledger/src/shred/wire.rs

@@ -18,7 +18,7 @@ use {
 };
 #[cfg(test)]
 use {
-    rand::{seq::SliceRandom, Rng},
+    rand::{prelude::IndexedMutRandom as _, Rng},
     solana_perf::packet::Packet,
     std::collections::HashMap,
     std::ops::Range,
@@ -370,7 +370,7 @@ pub(crate) fn corrupt_packet<R: Rng>(
     fn modify_packet<R: Rng>(rng: &mut R, packet: &mut Packet, offsets: Range<usize>) {
         let buffer = packet.buffer_mut();
         let byte = buffer[offsets].choose_mut(rng).unwrap();
-        *byte = rng.gen::<u8>().max(1u8).wrapping_add(*byte);
+        *byte = rng.random::<u8>().max(1u8).wrapping_add(*byte);
     }
     // We need to re-borrow the `packet` here, otherwise compiler considers it
     // as moved.
@@ -387,7 +387,7 @@ pub(crate) fn corrupt_packet<R: Rng>(
             ..
         } => Some((proof_size, resigned)),
     };
-    let coin_flip: bool = rng.gen();
+    let coin_flip: bool = rng.random();
     if coin_flip {
         // Corrupt one byte within the signature offsets.
         modify_packet(rng, packet, 0..SIGNATURE_BYTES);
@@ -445,9 +445,9 @@ mod tests {
         [true, false]
     )]
     fn test_resign_packet(repaired: bool, is_last_in_slot: bool) {
-        let mut rng = rand::thread_rng();
-        let slot = 318_230_963 + rng.gen_range(0..318_230_963);
-        let data_size = 1200 * rng.gen_range(32..64);
+        let mut rng = rand::rng();
+        let slot = 318_230_963 + rng.random_range(0..318_230_963);
+        let data_size = 1200 * rng.random_range(32..64);
         let mut shreds =
             make_merkle_shreds_for_tests(&mut rng, slot, data_size, is_last_in_slot).unwrap();
         // enumerate the shreds so that I have index of each shred
@@ -455,7 +455,7 @@ mod tests {
         for (index, shred) in shreds.iter_mut().enumerate() {
             let keypair = Keypair::new();
             let signature = make_dummy_signature(&mut rng);
-            let nonce = repaired.then(|| rng.gen::<Nonce>());
+            let nonce = repaired.then(|| rng.random::<Nonce>());
             let is_last_batch = index >= shreds_len - SHREDS_PER_FEC_BLOCK;
             if is_last_in_slot && is_last_batch {
                 shred.set_retransmitter_signature(&signature).unwrap();
@@ -503,9 +503,9 @@ mod tests {
         [true, false]
     )]
     fn test_merkle_shred_wire_layout(repaired: bool, is_last_in_slot: bool) {
-        let mut rng = rand::thread_rng();
-        let slot = 318_230_963 + rng.gen_range(0..318_230_963);
-        let data_size = 1200 * rng.gen_range(32..64);
+        let mut rng = rand::rng();
+        let slot = 318_230_963 + rng.random_range(0..318_230_963);
+        let data_size = 1200 * rng.random_range(32..64);
         let mut shreds =
             make_merkle_shreds_for_tests(&mut rng, slot, data_size, is_last_in_slot).unwrap();
         let shreds_len = shreds.len();
@@ -523,7 +523,7 @@ mod tests {
         }
 
         for (index, shred) in shreds.iter().enumerate() {
-            let nonce = repaired.then(|| rng.gen::<Nonce>());
+            let nonce = repaired.then(|| rng.random::<Nonce>());
             let is_last_batch = index >= shreds_len - SHREDS_PER_FEC_BLOCK;
             let mut packet = shred.payload().to_packet(nonce);
             if repaired {

ledger/src/shredder.rs

@@ -309,9 +309,9 @@ mod tests {
             &keypair,
             &entries,
             is_last_in_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            start_index,                                    // next_shred_index
-            start_index,                                    // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            start_index,                                // next_shred_index
+            start_index,                                // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         );
@@ -395,9 +395,9 @@ mod tests {
             &keypair,
             &entries,
             is_last_in_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            369,                                            // next_shred_index
-            776,                                            // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            369,                                        // next_shred_index
+            776,                                        // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         );
@@ -427,9 +427,9 @@ mod tests {
             &keypair,
             &entries,
             is_last_in_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            0,                                              // next_shred_index
-            0,                                              // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            0,                                          // next_shred_index
+            0,                                          // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         );
@@ -464,9 +464,9 @@ mod tests {
             &keypair,
             &entries,
             is_last_in_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            0,                                              // next_shred_index
-            0,                                              // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            0,                                          // next_shred_index
+            0,                                          // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         );
@@ -511,9 +511,9 @@ mod tests {
             &keypair,
             &entries,
             is_last_in_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            0,                                              // next_shred_index
-            0,                                              // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            0,                                          // next_shred_index
+            0,                                          // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         );
@@ -561,9 +561,9 @@ mod tests {
             &keypair,
             &entries,
             is_last_in_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            0,                                              // next_shred_index
-            0,                                              // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            0,                                          // next_shred_index
+            0,                                          // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         );
@@ -595,9 +595,9 @@ mod tests {
             &keypair,
             &entries,
             is_last_in_slot,
-            Hash::new_from_array(rand::thread_rng().gen()), // chained_merkle_root
-            start_index,                                    // next_shred_index
-            start_index,                                    // next_code_index
+            Hash::new_from_array(rand::rng().random()), // chained_merkle_root
+            start_index,                                // next_shred_index
+            start_index,                                // next_code_index
             &ReedSolomonCache::default(),
             &mut ProcessShredsStats::default(),
         );

ledger/src/sigverify_shreds.rs

@@ -280,28 +280,28 @@ mod tests {
     }
 
     fn make_transaction<R: Rng>(rng: &mut R) -> Transaction {
-        let block = rng.gen::<[u8; 32]>();
+        let block = rng.random::<[u8; 32]>();
         let recent_blockhash = solana_sha256_hasher::hashv(&[&block]);
         system_transaction::transfer(
             &Keypair::new(),       // from
             &Pubkey::new_unique(), // to
-            rng.gen(),             // lamports
+            rng.random(),          // lamports
             recent_blockhash,
         )
     }
 
     fn make_entry<R: Rng>(rng: &mut R, prev_hash: &Hash) -> Entry {
-        let size = rng.gen_range(16..32);
+        let size = rng.random_range(16..32);
         let txs = repeat_with(|| make_transaction(rng)).take(size).collect();
         Entry::new(
             prev_hash,
-            rng.gen_range(1..64), // num_hashes
+            rng.random_range(1..64), // num_hashes
             txs,
         )
     }
 
     fn make_entries<R: Rng>(rng: &mut R, num_entries: usize) -> Vec<Entry> {
-        let prev_hash = solana_sha256_hasher::hashv(&[&rng.gen::<[u8; 32]>()]);
+        let prev_hash = solana_sha256_hasher::hashv(&[&rng.random::<[u8; 32]>()]);
         let entry = make_entry(rng, &prev_hash);
         std::iter::successors(Some(entry), |entry| Some(make_entry(rng, &entry.hash)))
             .take(num_entries)
@@ -317,22 +317,22 @@ mod tests {
         let mut shreds: Vec<_> = keypairs
             .iter()
             .flat_map(|(&slot, keypair)| {
-                let parent_slot = slot - rng.gen::<u16>().max(1) as Slot;
-                let num_entries = rng.gen_range(64..128);
+                let parent_slot = slot - rng.random::<u16>().max(1) as Slot;
+                let num_entries = rng.random_range(64..128);
                 Shredder::new(
                     slot,
                     parent_slot,
-                    rng.gen_range(0..0x40), // reference_tick
-                    rng.gen(),              // version
+                    rng.random_range(0..0x40), // reference_tick
+                    rng.random(),              // version
                 )
                 .unwrap()
                 .make_merkle_shreds_from_entries(
                     keypair,
                     &make_entries(rng, num_entries),
                     is_last_in_slot,
-                    Hash::new_from_array(rng.gen()), // chained_merkle_root
-                    rng.gen_range(0..2671),          // next_shred_index
-                    rng.gen_range(0..2781),          // next_code_index
+                    Hash::new_from_array(rng.random()), // chained_merkle_root
+                    rng.random_range(0..2671),          // next_shred_index
+                    rng.random_range(0..2781),          // next_code_index
                     &reed_solomon_cache,
                     &mut ProcessShredsStats::default(),
                 )
@@ -364,7 +364,7 @@ mod tests {
             packet
         });
         let packets: Vec<PacketBatch> = repeat_with(|| {
-            let size = rng.gen_range(0..16);
+            let size = rng.random_range(0..16);
             let packets = packets.by_ref().take(size).collect();
             let batch = RecycledPacketBatch::new(packets);
             (size == 0 || !batch.is_empty()).then_some(batch.into())
@@ -381,10 +381,10 @@ mod tests {
     #[test_case(true)]
     #[test_case(false)]
     fn test_verify_shreds_fuzz(is_last_in_slot: bool) {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let cache = RwLock::new(LruCache::new(/*capacity:*/ 128));
         let thread_pool = ThreadPoolBuilder::new().num_threads(3).build().unwrap();
-        let keypairs = repeat_with(|| rng.gen_range(169_367_809..169_906_789))
+        let keypairs = repeat_with(|| rng.random_range(169_367_809..169_906_789))
             .map(|slot| (slot, Keypair::new()))
             .take(3)
             .collect();
@@ -412,7 +412,7 @@ mod tests {
                 packets
                     .iter_mut()
                     .map(|packet| {
-                        let coin_flip: bool = rng.gen();
+                        let coin_flip: bool = rng.random();
                         if !coin_flip {
                             shred::layout::corrupt_packet(&mut rng, packet, &keypairs);
                         }
@@ -427,11 +427,11 @@ mod tests {
     #[test_case(true)]
     #[test_case(false)]
     fn test_sign_shreds(is_last_in_slot: bool) {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let cache = RwLock::new(LruCache::new(/*capacity:*/ 128));
         let thread_pool = ThreadPoolBuilder::new().num_threads(3).build().unwrap();
         let shreds = {
-            let keypairs = repeat_with(|| rng.gen_range(169_367_809..169_906_789))
+            let keypairs = repeat_with(|| rng.random_range(169_367_809..169_906_789))
                 .map(|slot| (slot, Keypair::new()))
                 .take(3)
                 .collect();

ledger/src/staking_utils.rs

@@ -126,10 +126,10 @@ pub(crate) mod tests {
                 &Clock::default(),
             ),
         ));
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let vote_accounts = stakes.into_iter().map(|(stake, vote_state)| {
             let account = AccountSharedData::new_data(
-                rng.gen(), // lamports
+                rng.random(), // lamports
                 &VoteStateVersions::new_v4(vote_state),
                 &solana_vote_program::id(), // owner
             )

programs/sbf/Cargo.lock

@@ -7395,7 +7395,9 @@ dependencies = [
  "prost",
  "qualifier_attr",
  "rand 0.8.5",
+ "rand 0.9.2",
  "rand_chacha 0.3.1",
+ "rand_chacha 0.9.0",
  "rayon",
  "reed-solomon-erasure",
  "rocksdb",