refactor(net): use provided RNG for random value generation

crates/net/discv4/src/test_utils.rs

@@ -1,6 +1,5 @@
 //! Mock discovery support
 
-// TODO(rand): update ::random calls after rand_09 migration
 
 use crate::{
     proto::{FindNode, Message, Neighbours, NodeEndpoint, Packet, Ping, Pong},
@@ -267,26 +266,23 @@ pub fn rng_endpoint(rng: &mut impl Rng) -> NodeEndpoint {
 /// Generates a random [`NodeRecord`] using the provided random number generator.
 pub fn rng_record(rng: &mut impl RngCore) -> NodeRecord {
     let NodeEndpoint { address, udp_port, tcp_port } = rng_endpoint(rng);
-    // TODO(rand)
-    NodeRecord { address, tcp_port, udp_port, id: B512::random() }
+    NodeRecord { address, tcp_port, udp_port, id: rng.gen() }
 }
 
 /// Generates a random IPv6 [`NodeRecord`] using the provided random number generator.
 pub fn rng_ipv6_record(rng: &mut impl RngCore) -> NodeRecord {
     let mut ip = [0u8; 16];
     rng.fill_bytes(&mut ip);
     let address = IpAddr::V6(ip.into());
-    // TODO(rand)
-    NodeRecord { address, tcp_port: rng.r#gen(), udp_port: rng.r#gen(), id: B512::random() }
+    NodeRecord { address, tcp_port: rng.r#gen(), udp_port: rng.r#gen(), id: rng.gen() }
 }
 
 /// Generates a random IPv4 [`NodeRecord`] using the provided random number generator.
 pub fn rng_ipv4_record(rng: &mut impl RngCore) -> NodeRecord {
     let mut ip = [0u8; 4];
     rng.fill_bytes(&mut ip);
     let address = IpAddr::V4(ip.into());
-    // TODO(rand)
-    NodeRecord { address, tcp_port: rng.r#gen(), udp_port: rng.r#gen(), id: B512::random() }
+    NodeRecord { address, tcp_port: rng.r#gen(), udp_port: rng.r#gen(), id: rng.gen() }
 }
 
 /// Generates a random [`Message`] using the provided random number generator.
@@ -304,7 +300,7 @@ pub fn rng_message(rng: &mut impl RngCore) -> Message {
             expire: rng.r#gen(),
             enr_sq: None,
         }),
-        3 => Message::FindNode(FindNode { id: B512::random(), expire: rng.r#gen() }),
+        3 => Message::FindNode(FindNode { id: rng.gen(), expire: rng.r#gen() }),
         4 => {
             let num: usize = rng.gen_range(1..=SAFE_MAX_DATAGRAM_NEIGHBOUR_RECORDS);
             Message::Neighbours(Neighbours {

crates/net/dns/src/lib.rs

@@ -220,7 +220,7 @@ impl<R: Resolver> DnsDiscoveryService<R> {
             // already resolved
             let cached = ResolveEntryResult { entry: Some(Ok(entry)), link, hash, kind };
             self.on_resolved_entry(cached);
-            return
+            return;
         }
         self.queries.resolve_entry(link, hash, kind)
     }
@@ -298,7 +298,7 @@ impl<R: Resolver> DnsDiscoveryService<R> {
         loop {
             // drain buffered events first
             if let Some(event) = self.queued_events.pop_front() {
-                return Poll::Ready(event)
+                return Poll::Ready(event);
             }
 
             // process all incoming commands
@@ -351,7 +351,7 @@ impl<R: Resolver> DnsDiscoveryService<R> {
             }
 
             if !progress && self.queued_events.is_empty() {
-                return Poll::Pending
+                return Poll::Pending;
             }
         }
     }
@@ -393,16 +393,24 @@ pub enum DnsDiscoveryEvent {
 
 /// Converts an [Enr] into a [`NodeRecord`]
 fn convert_enr_node_record(enr: &Enr<SecretKey>) -> Option<DnsNodeRecordUpdate> {
+    let id = pk2id(&enr.public_key());
+
     let node_record = NodeRecord {
         address: enr.ip4().map(IpAddr::from).or_else(|| enr.ip6().map(IpAddr::from))?,
         tcp_port: enr.tcp4().or_else(|| enr.tcp6())?,
         udp_port: enr.udp4().or_else(|| enr.udp6())?,
-        id: pk2id(&enr.public_key()),
+        id,
     }
     .into_ipv4_mapped();
 
-    let fork_id =
-        enr.get_decodable::<EnrForkIdEntry>(b"eth").transpose().ok().flatten().map(Into::into);
+    let fork_id = match enr.get_decodable::<EnrForkIdEntry>(b"eth").transpose() {
+        Ok(Some(entry)) => Some(entry.into()),
+        Ok(None) => None,
+        Err(err) => {
+            trace!(?err, ?id, "invalid fork id entry in ENR");
+            None
+        }
+    };
 
     Some(DnsNodeRecordUpdate { node_record, fork_id, enr: enr.clone() })
 }
@@ -414,6 +422,7 @@ mod tests {
     use alloy_chains::Chain;
     use alloy_rlp::{Decodable, Encodable};
     use enr::EnrKey;
+    use rand::{rngs::StdRng, RngCore, SeedableRng};
     use reth_chainspec::MAINNET;
     use reth_ethereum_forks::{EthereumHardfork, ForkHash};
     use secp256k1::rand::thread_rng;
@@ -446,12 +455,16 @@ mod tests {
         // rig
 
         let secret_key = SecretKey::new(&mut secp256k1::rand::thread_rng());
+        let mut rng = StdRng::seed_from_u64(1);
+        let mut fork_hash = [0u8; 4];
+        rng.fill_bytes(&mut fork_hash);
+        let next = rng.next_u64();
         let enr = Enr::builder()
             .ip("127.0.0.1".parse().unwrap())
             .udp4(9000)
             .tcp4(30303)
             .add_value(b"eth", &EnrForkIdEntry::from(MAINNET.latest_fork_id()))
-            .add_value(b"opstack", &ForkId { hash: ForkHash(rand::random()), next: rand::random() })
+            .add_value(b"opstack", &ForkId { hash: ForkHash(fork_hash), next })
             .build(&secret_key)
             .unwrap();
 

crates/net/ecies/src/algorithm.rs

@@ -312,9 +312,8 @@ impl ECIES {
 
     /// Create a new ECIES client with the given static secret key and remote peer ID.
     pub fn new_client(secret_key: SecretKey, remote_id: PeerId) -> Result<Self, ECIESError> {
-        // TODO(rand): use rng for nonce
         let mut rng = rng();
-        let nonce = B256::random();
+        let nonce = rng.gen();
         let ephemeral_secret_key = SecretKey::new(&mut rng);
         Self::new_static_client(secret_key, remote_id, nonce, ephemeral_secret_key)
     }
@@ -356,7 +355,7 @@ impl ECIES {
     /// Create a new ECIES server with the given static secret key.
     pub fn new_server(secret_key: SecretKey) -> Result<Self, ECIESError> {
         let mut rng = rng();
-        let nonce = B256::random();
+        let nonce = rng.gen();
         let ephemeral_secret_key = SecretKey::new(&mut rng);
         Self::new_static_server(secret_key, nonce, ephemeral_secret_key)
     }

testing/testing-utils/src/generators.rs

@@ -1,7 +1,5 @@
 //! Generators for different data structures like block headers, block bodies and ranges of those.
 
-// TODO(rand): update ::random calls after rand_09 migration
-
 use alloy_consensus::{Header, SignableTransaction, Transaction as _, TxLegacy};
 use alloy_eips::{
     eip1898::BlockWithParent,
@@ -345,7 +343,7 @@ where
                 let old = if entry.value.is_zero() {
                     let old = storage.remove(&entry.key);
                     if matches!(old, Some(U256::ZERO)) {
-                        return None
+                        return None;
                     }
                     old
                 } else {
@@ -442,7 +440,7 @@ pub fn random_contract_account_range<R: Rng>(
     for _ in acc_range {
         let (address, eoa_account) = random_eoa_account(rng);
         // todo: can a non-eoa account have a nonce > 0?
-        let account = Account { bytecode_hash: Some(B256::random()), ..eoa_account };
+        let account = Account { bytecode_hash: Some(rng.random()), ..eoa_account };
         accounts.push((address, account))
     }
     accounts
@@ -477,7 +475,7 @@ pub fn random_log<R: Rng>(rng: &mut R, address: Option<Address>, topics_count: O
     let topics_count = topics_count.unwrap_or_else(|| rng.random()) as usize;
     Log::new_unchecked(
         address.unwrap_or_else(|| Address::random()),
-        std::iter::repeat_with(|| B256::random()).take(topics_count).collect(),
+        std::iter::repeat_with(|| rng.random()).take(topics_count).collect(),
         std::iter::repeat_with(|| rng.random()).take(data_byte_count).collect::<Vec<_>>().into(),
     )
 }