genesis: require passing in an rng when using ValidatorBuilder

config/management/genesis/src/swarm_config.rs

@@ -64,7 +64,7 @@ impl SwarmConfig {
 
 impl BuildSwarm for ValidatorBuilder {
     fn build_swarm(&self) -> Result<(Vec<NodeConfig>, Ed25519PrivateKey)> {
-        let (root_keys, validators) = self.clone().build()?;
+        let (root_keys, validators) = self.clone().build(rand::rngs::OsRng)?;
 
         Ok((
             validators.into_iter().map(|v| v.config).collect(),

config/management/genesis/src/validator_builder.rs

@@ -130,14 +130,14 @@ pub struct RootKeys {
 }
 
 impl RootKeys {
-    pub fn generate<R>(rng: &mut R) -> Self
+    pub fn generate<R>(mut rng: R) -> Self
     where
         R: ::rand::RngCore + ::rand::CryptoRng,
     {
         // TODO use distinct keys for diem root and treasury
         // let root_key = Ed25519PrivateKey::generate(rng);
         // let treasury_compliance_key = Ed25519PrivateKey::generate(rng);
-        let key = Ed25519PrivateKey::generate(rng).to_bytes();
+        let key = Ed25519PrivateKey::generate(&mut rng).to_bytes();
         let root_key = Ed25519PrivateKey::try_from(key.as_ref()).unwrap();
         let treasury_compliance_key = Ed25519PrivateKey::try_from(key.as_ref()).unwrap();
 
@@ -189,10 +189,10 @@ impl ValidatorBuilder {
         self
     }
 
-    pub fn build(mut self) -> Result<(RootKeys, Vec<ValidatorConfig>)> {
-        // TODO Pass this in
-        let mut rng = rand::rngs::OsRng;
-
+    pub fn build<R>(mut self, mut rng: R) -> Result<(RootKeys, Vec<ValidatorConfig>)>
+    where
+        R: ::rand::RngCore + ::rand::CryptoRng,
+    {
         // Canonicalize the config directory path
         self.config_directory = self.config_directory.canonicalize()?;
 
@@ -254,7 +254,7 @@ impl ValidatorBuilder {
     fn initialize_validator_config<R>(
         &self,
         index: usize,
-        rng: &mut R,
+        rng: R,
         validator_network_address_encryption_key: NetworkAddressEncryptionKey,
         validator_network_address_encryption_key_version: NetworkAddressEncryptionKeyVersion,
     ) -> Result<ValidatorConfig>
@@ -321,7 +321,7 @@ impl ValidatorBuilder {
 
     fn initialize_validator_storage<R>(
         validator: &ValidatorConfig,
-        rng: &mut R,
+        mut rng: R,
         validator_network_address_encryption_key: NetworkAddressEncryptionKey,
         validator_network_address_encryption_key_version: NetworkAddressEncryptionKeyVersion,
     ) -> Result<()>
@@ -331,22 +331,22 @@ impl ValidatorBuilder {
         let mut storage = validator.storage();
 
         // Set owner key and account address
-        storage.import_private_key(OWNER_KEY, Ed25519PrivateKey::generate(rng))?;
+        storage.import_private_key(OWNER_KEY, Ed25519PrivateKey::generate(&mut rng))?;
         let owner_address =
             diem_config::utils::validator_owner_account_from_name(validator.owner().as_bytes());
         storage.set(OWNER_ACCOUNT, owner_address)?;
 
         // Set operator key and account address
-        let operator_key = Ed25519PrivateKey::generate(rng);
+        let operator_key = Ed25519PrivateKey::generate(&mut rng);
         let operator_address =
             AuthenticationKey::ed25519(&Ed25519PublicKey::from(&operator_key)).derived_address();
         storage.set(OPERATOR_ACCOUNT, operator_address)?;
         storage.import_private_key(OPERATOR_KEY, operator_key)?;
 
-        storage.import_private_key(CONSENSUS_KEY, Ed25519PrivateKey::generate(rng))?;
-        storage.import_private_key(EXECUTION_KEY, Ed25519PrivateKey::generate(rng))?;
-        storage.import_private_key(FULLNODE_NETWORK_KEY, Ed25519PrivateKey::generate(rng))?;
-        storage.import_private_key(VALIDATOR_NETWORK_KEY, Ed25519PrivateKey::generate(rng))?;
+        storage.import_private_key(CONSENSUS_KEY, Ed25519PrivateKey::generate(&mut rng))?;
+        storage.import_private_key(EXECUTION_KEY, Ed25519PrivateKey::generate(&mut rng))?;
+        storage.import_private_key(FULLNODE_NETWORK_KEY, Ed25519PrivateKey::generate(&mut rng))?;
+        storage.import_private_key(VALIDATOR_NETWORK_KEY, Ed25519PrivateKey::generate(&mut rng))?;
 
         // Initialize all other data in storage
         storage.set(SAFETY_DATA, SafetyData::new(0, 0, 0, 0, None))?;

testsuite/forge/src/backend/k8s/mod.rs

@@ -3,6 +3,7 @@
 
 use crate::{Factory, Result, Swarm, Version};
 use anyhow::format_err;
+use rand::rngs::StdRng;
 use std::{env, fs::File, io::Read, num::NonZeroUsize, path::PathBuf};
 use tokio::runtime::Runtime;
 
@@ -73,7 +74,12 @@ impl Factory for K8sFactory {
         )))
     }
 
-    fn launch_swarm(&self, _node_num: NonZeroUsize, _version: &Version) -> Result<Box<dyn Swarm>> {
+    fn launch_swarm(
+        &self,
+        _rng: &mut StdRng,
+        _node_num: NonZeroUsize,
+        _version: &Version,
+    ) -> Result<Box<dyn Swarm>> {
         let rt = Runtime::new().unwrap();
         let swarm = rt
             .block_on(K8sSwarm::new(

testsuite/forge/src/backend/local/mod.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{Factory, Result, Swarm, Version};
+use rand::rngs::StdRng;
 use std::{
     collections::HashMap,
     num::NonZeroUsize,
@@ -120,11 +121,16 @@ impl Factory for LocalFactory {
         Box::new(self.versions.keys().cloned())
     }
 
-    fn launch_swarm(&self, node_num: NonZeroUsize, version: &Version) -> Result<Box<dyn Swarm>> {
+    fn launch_swarm(
+        &self,
+        rng: &mut StdRng,
+        node_num: NonZeroUsize,
+        version: &Version,
+    ) -> Result<Box<dyn Swarm>> {
         let mut swarm = LocalSwarm::builder(self.versions.clone())
             .number_of_validators(node_num)
             .initial_version(version.clone())
-            .build()?;
+            .build(rng)?;
         swarm.launch()?;
 
         Ok(Box::new(swarm))

testsuite/forge/src/backend/local/swarm.rs

@@ -115,7 +115,10 @@ impl LocalSwarmBuilder {
         self
     }
 
-    pub fn build(self) -> Result<LocalSwarm> {
+    pub fn build<R>(self, rng: R) -> Result<LocalSwarm>
+    where
+        R: ::rand::RngCore + ::rand::CryptoRng,
+    {
         let dir = if let Some(dir) = self.dir {
             if dir.exists() {
                 fs::remove_dir_all(&dir)?;
@@ -132,7 +135,7 @@ impl LocalSwarmBuilder {
         )
         .num_validators(self.number_of_validators)
         .template(self.template)
-        .build()?;
+        .build(rng)?;
 
         // Get the initial version to start the nodes with, either the one provided or fallback to
         // using the the latest version

testsuite/forge/src/interface/factory.rs

@@ -3,11 +3,17 @@
 
 use super::{Swarm, Version};
 use crate::Result;
+use rand::rngs::StdRng;
 use std::num::NonZeroUsize;
 
 /// Trait used to represent a interface for constructing a launching new networks
 pub trait Factory {
     fn versions<'a>(&'a self) -> Box<dyn Iterator<Item = Version> + 'a>;
 
-    fn launch_swarm(&self, node_num: NonZeroUsize, version: &Version) -> Result<Box<dyn Swarm>>;
+    fn launch_swarm(
+        &self,
+        rng: &mut StdRng,
+        node_num: NonZeroUsize,
+        version: &Version,
+    ) -> Result<Box<dyn Swarm>>;
 }

testsuite/forge/src/runner.rs

@@ -214,9 +214,11 @@ impl<'cfg, F: Factory> Forge<'cfg, F> {
         if test_count > 0 {
             let initial_version = self.initial_version();
             let mut rng = ::rand::rngs::StdRng::from_seed(OsRng.gen());
-            let mut swarm = self
-                .factory
-                .launch_swarm(self.tests.initial_validator_count, &initial_version)?;
+            let mut swarm = self.factory.launch_swarm(
+                &mut rng,
+                self.tests.initial_validator_count,
+                &initial_version,
+            )?;
 
             // Run PublicUsageTests
             for test in self.filter_tests(self.tests.public_usage_tests.iter()) {