Update dependencies: freenet-stdlib 0.1.14, rand 0.9, tokio-tungstenite 0.27

Cargo.toml

@@ -22,7 +22,7 @@ ctrlc = { version = "3" }
 dashmap = "^6.1"
 either = "1"
 futures = "0.3"
-rand = { version = "0.8" }
+rand = { version = "0.9" }
 semver = { version = "1",  features = ["serde"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

apps/freenet-email-app/Cargo.toml

@@ -19,6 +19,6 @@ rsa = { version = "0.9.2", default-features = false, features = ["serde", "pem",
 serde = "1"
 serde_json = "1"
 
-# freenet-stdlib = { version = "0.0.7" }
-freenet-stdlib = { version = "0.1.6" }
+# freenet-stdlib = { version = "0.1.14" }
+freenet-stdlib = { version = "0.1.14" }
 freenet-aft-interface = { path = "../../modules/antiflood-tokens/interfaces" }

apps/freenet-microblogging/Cargo.toml

@@ -14,7 +14,7 @@ panic = 'abort'
 strip = true
 
 [workspace.dependencies]
-freenet-stdlib = { version = "0.1.6", default-features = false, features = ["contract"] }
+freenet-stdlib = { version = "0.1.14", default-features = false, features = ["contract"] }
 
 #[target.wasm32-unknown-unknown]
 #rustflags = ["-C", "link-arg=--import-memory"]

apps/freenet-ping/Cargo.toml

@@ -4,7 +4,7 @@ members = ["contracts/ping", "app", "types"]
 
 [workspace.dependencies]
 # freenet-stdlib = { path = "./../../stdlib/rust", features = ["contract"] }
-freenet-stdlib = { version = "0.1.11" } 
+freenet-stdlib = { version = "0.1.14" } 
 freenet-ping-types = { path = "types", default-features = false }
 chrono = { version = "0.4", default-features = false }
 testresult = "0.4"

apps/freenet-ping/app/Cargo.toml

@@ -13,7 +13,7 @@ clap = { version = "4.5", features = ["derive"] }
 freenet-stdlib = { version = "0.1.14", features = ["net"] }
 freenet-ping-types = { path = "../types", features = ["std", "clap"] }
 futures = "0.3.31"
-rand = "0.8.5"
+rand = "0.9.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tempfile = "3.21.0"

apps/freenet-ping/app/tests/common/mod.rs

@@ -103,7 +103,7 @@ pub async fn base_node_test_config_with_rng(
         tempfile::Builder::new().prefix(data_dir_suffix).tempdir()?
     };
 
-    let key = TransportKeypair::new_with_rng(rng);
+    let key = TransportKeypair::new();
     let transport_keypair = temp_dir.path().join("private.pem");
     key.save(&transport_keypair)?;
     key.public().save(temp_dir.path().join("public.pem"))?;
@@ -119,7 +119,7 @@ pub async fn base_node_test_config_with_rng(
             is_gateway,
             skip_load_from_network: true,
             gateways: Some(gateways),
-            location: Some(rng.gen()),
+            location: Some(rng.random()),
             ignore_protocol_checking: true,
             address: Some(Ipv4Addr::LOCALHOST.into()),
             network_port: public_port, // if None, node will pick a free one or use default
@@ -150,7 +150,7 @@ pub fn gw_config_from_path_with_rng(
 ) -> Result<InlineGwConfig> {
     Ok(InlineGwConfig {
         address: (Ipv4Addr::LOCALHOST, port).into(),
-        location: Some(rng.gen()),
+        location: Some(rng.random()),
         public_key_path: path.join("public.pem"),
     })
 }

crates/core/src/client_events/mod.rs

@@ -71,7 +71,7 @@ impl AuthToken {
 
     pub fn generate() -> AuthToken {
         use rand::Rng;
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut token = [0u8; 32];
         rng.fill(&mut token);
         let token_str = bs58::encode(token).into_string();
@@ -767,7 +767,7 @@ pub(crate) mod test {
         prelude::*,
     };
     use futures::{FutureExt, StreamExt};
-    use rand::{seq::SliceRandom, SeedableRng};
+    use rand::SeedableRng;
     use tokio::net::TcpStream;
     use tokio::sync::watch::Receiver;
     use tokio::sync::Mutex;
@@ -1181,13 +1181,15 @@ pub(crate) mod test {
         }
     }
 
+    use rand::prelude::IndexedRandom;
+
     impl RandomEventGenerator for rand::rngs::SmallRng {
         fn gen_u8(&mut self) -> u8 {
-            <Self as rand::Rng>::gen(self)
+            <Self as rand::Rng>::random(self)
         }
 
         fn gen_range(&mut self, range: std::ops::Range<usize>) -> usize {
-            <Self as rand::Rng>::gen_range(self, range)
+            <Self as rand::Rng>::random_range(self, range)
         }
 
         fn choose<'a, T>(&mut self, vec: &'a [T]) -> Option<&'a T> {

crates/core/src/config/mod.rs

@@ -1109,7 +1109,7 @@ mod tests {
 
         let url = server.url_str("/gateways");
 
-        let key = rsa::RsaPrivateKey::new(&mut rand::thread_rng(), 256).unwrap();
+        let key = rsa::RsaPrivateKey::new(&mut rsa::rand_core::OsRng, 256).unwrap();
         let key = key
             .to_public_key()
             .to_public_key_pem(pkcs8::LineEnding::default())

crates/core/src/node/mod.rs

@@ -913,7 +913,7 @@ impl PeerId {
     pub fn random() -> Self {
         use rand::Rng;
         let mut addr = [0; 4];
-        rand::thread_rng().fill(&mut addr[..]);
+        rand::rng().fill(&mut addr[..]);
         let port = crate::util::get_free_port().unwrap();
 
         let pub_key = PEER_ID.with(|peer_id| {

crates/core/src/node/network_bridge/in_memory.rs

@@ -119,7 +119,7 @@ impl InMemoryTransport {
         let ip = interface_peer.clone();
         GlobalExecutor::spawn(async move {
             const MAX_DELAYED_MSG: usize = 10;
-            let mut rng = StdRng::from_entropy();
+            let mut rng = StdRng::seed_from_u64(rand::random());
             // delayed messages per target
             let mut delayed: HashMap<_, Vec<_>> = HashMap::with_capacity(MAX_DELAYED_MSG);
             let last_drain = Instant::now();
@@ -131,7 +131,7 @@ impl InMemoryTransport {
                             ip,
                             msg.origin
                         );
-                        if rng.gen_bool(0.5) && delayed.len() < MAX_DELAYED_MSG && add_noise {
+                        if rng.random_bool(0.5) && delayed.len() < MAX_DELAYED_MSG && add_noise {
                             delayed
                                 .entry(msg.target.clone())
                                 .or_default()
@@ -140,7 +140,7 @@ impl InMemoryTransport {
                         } else {
                             let mut queue = msg_stack_queue_cp.lock().await;
                             queue.push(msg);
-                            if add_noise && rng.gen_bool(0.2) {
+                            if add_noise && rng.random_bool(0.2) {
                                 queue.shuffle(&mut rng);
                             }
                         }
@@ -157,7 +157,7 @@ impl InMemoryTransport {
                         tokio::time::sleep(Duration::from_millis(10)).await
                     }
                 }
-                if (last_drain.elapsed() > Duration::from_millis(rng.gen_range(1_000..5_000))
+                if (last_drain.elapsed() > Duration::from_millis(rng.random_range(1_000..5_000))
                     && !delayed.is_empty())
                     || delayed.len() == MAX_DELAYED_MSG
                 {

crates/core/src/node/testing_impl.rs

@@ -1,7 +1,7 @@
 use either::Either;
 use freenet_stdlib::prelude::*;
 use futures::Future;
-use rand::seq::SliceRandom;
+use rand::prelude::IndexedRandom;
 use std::{
     collections::{HashMap, HashSet},
     net::Ipv6Addr,

crates/core/src/ring/connection_manager.rs

@@ -1,4 +1,5 @@
 use parking_lot::Mutex;
+use rand::prelude::IndexedRandom;
 
 use crate::topology::{Limits, TopologyManager};
 
@@ -336,13 +337,13 @@ impl ConnectionManager {
         if amount == 0 {
             return None;
         }
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut attempts = 0;
         loop {
             if attempts >= amount * 2 {
                 return None;
             }
-            let selected = rng.gen_range(0..amount);
+            let selected = rng.random_range(0..amount);
             let (peer, loc) = peers.iter().nth(selected).expect("infallible");
             if !filter_fn(peer) {
                 attempts += 1;
@@ -364,10 +365,9 @@ impl ConnectionManager {
         skip_list: impl Contains<PeerId>,
         router: &Router,
     ) -> Option<PeerKeyLocation> {
-        use rand::seq::SliceRandom;
         let connections = self.connections_by_location.read();
         let peers = connections.values().filter_map(|conns| {
-            let conn = conns.choose(&mut rand::thread_rng())?;
+            let conn = conns.choose(&mut rand::rng())?;
             if let Some(requester) = requesting {
                 if requester == &conn.location.peer {
                     return None;

crates/core/src/ring/location.rs

@@ -51,8 +51,8 @@ impl Location {
     /// Returns a new random location.
     pub fn random() -> Self {
         use rand::prelude::*;
-        let mut rng = rand::thread_rng();
-        Location(rng.gen_range(0.0..=1.0))
+        let mut rng = rand::rng();
+        Location(rng.random_range(0.0..=1.0))
     }
 
     /// Compute the distance between two locations.
@@ -259,7 +259,7 @@ mod test {
         // Generate 100 random IP addresses wih seeded RNG
         let ips = (0..100)
             .map(|_| {
-                let ip = Ipv4Addr::new(rng.gen(), rng.gen(), rng.gen(), rng.gen());
+                let ip = Ipv4Addr::new(rng.random(), rng.random(), rng.random(), rng.random());
                 SocketAddr::new(IpAddr::V4(ip), 12345)
             })
             .collect::<Vec<_>>();

crates/core/src/ring/mod.rs

@@ -22,7 +22,7 @@ use either::Either;
 use freenet_stdlib::prelude::ContractKey;
 use itertools::Itertools;
 use parking_lot::RwLock;
-use rand::Rng;
+use rand::{prelude::IndexedRandom, Rng};
 
 use crate::message::TransactionType;
 use crate::topology::rate::Rate;
@@ -287,8 +287,7 @@ impl Ring {
         // Get all connected peers through the connection manager
         let connections = self.connection_manager.get_connections_by_location();
         let peers = connections.values().filter_map(|conns| {
-            use rand::seq::SliceRandom;
-            let conn = conns.choose(&mut rand::thread_rng())?;
+            let conn = conns.choose(&mut rand::rng())?;
             (!skip_list.has_element(conn.location.peer.clone())).then_some(&conn.location)
         });
 
@@ -355,7 +354,6 @@ impl Ring {
         location: Location,
         skip_list: HashSet<PeerId>,
     ) -> Option<PeerKeyLocation> {
-        use rand::seq::SliceRandom;
         self.connection_manager
             .get_connections_by_location()
             .iter()
@@ -364,7 +362,7 @@ impl Ring {
             })
             .find_map(|(_, conns)| {
                 for _ in 0..conns.len() {
-                    let conn = conns.choose(&mut rand::thread_rng()).unwrap();
+                    let conn = conns.choose(&mut rand::rng()).unwrap();
                     let selected =
                         (!skip_list.contains(&conn.location.peer)).then_some(conn.location.clone());
                     if selected.is_some() {

crates/core/src/router/mod.rs

@@ -380,16 +380,16 @@ mod tests {
 
         // Create NUM_EVENTS random events
         let mut events = vec![];
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         for _ in 0..NUM_EVENTS {
-            let peer = peers[rng.gen_range(0..NUM_PEERS)].clone();
+            let peer = peers[rng.random_range(0..NUM_PEERS)].clone();
             let contract_location = Location::random();
             let simulated_prediction =
                 simulate_prediction(&mut rng, peer.clone(), contract_location);
             let event = RouteEvent {
                 peer,
                 contract_location,
-                outcome: if rng.gen_range(0.0..1.0) > simulated_prediction.failure_probability {
+                outcome: if rng.random_range(0.0..1.0) > simulated_prediction.failure_probability {
                     RouteOutcome::Success {
                         time_to_response_start: Duration::from_secs_f64(
                             simulated_prediction.time_to_response_start,
@@ -523,7 +523,7 @@ mod tests {
         let time_to_response_start = 2.0 * distance.as_f64();
         let failure_prob = distance.as_f64();
         let transfer_speed = 100.0 - (100.0 * distance.as_f64());
-        let payload_size = random.gen_range(100..1000);
+        let payload_size = random.random_range(100..1000);
         let transfer_time = transfer_speed * (payload_size as f64);
         RoutingPrediction {
             failure_probability: failure_prob,

crates/core/src/topology/small_world_rand.rs

@@ -1,6 +1,6 @@
 #[cfg(test)]
 pub(super) mod test_utils {
-    use rand::Rng;
+    use rand::random;
 
     use crate::ring::Distance;
 
@@ -9,7 +9,7 @@ pub(super) mod test_utils {
         let d_max = 0.5;
 
         // Generate a uniform random number between 0 and 1
-        let u: f64 = rand::thread_rng().gen_range(0.0..1.0);
+        let u: f64 = random();
 
         // Correct Inverse CDF: F^{-1}(u) = d_min * (d_max / d_min).powf(u)
         let d = d_min.as_f64() * (d_max / d_min.as_f64()).powf(u);

crates/core/src/transport/connection_handler.rs

@@ -171,7 +171,13 @@ impl OutboundConnectionHandler {
         // in RemoteConnection. The bandwidth_limit parameter is still passed to RemoteConnection
         // for this purpose (default: 3 MB/s).
         task::spawn(bw_tracker.rate_limiter(None, socket));
-        task::spawn(RANDOM_U64.scope(StdRng::from_entropy().gen(), transport.listen()));
+        task::spawn(RANDOM_U64.scope(
+            {
+                let mut rng = StdRng::seed_from_u64(rand::random());
+                rng.random()
+            },
+            transport.listen(),
+        ));
 
         Ok((connection_handler, new_connection_notifier))
     }
@@ -1248,7 +1254,7 @@ mod test {
             match &self.packet_drop_policy {
                 PacketDropPolicy::ReceiveAll => {}
                 PacketDropPolicy::Factor(factor) => {
-                    if *factor > self.rng.try_lock().unwrap().gen::<f64>() {
+                    if *factor > self.rng.try_lock().unwrap().random::<f64>() {
                         tracing::trace!(id=%packet_idx, %self.this, "drop packet");
                         return Ok(buf.len());
                     }
@@ -1927,7 +1933,7 @@ mod test {
         let mut test_no = 0;
         for _ in 0..2 {
             for factor in std::iter::repeat(())
-                .map(|_| rng.gen::<f64>())
+                .map(|_| rng.random::<f64>())
                 .filter(|x| *x > 0.05 && *x < 0.25)
                 .take(3)
             {

crates/core/src/transport/crypto.rs

@@ -1,7 +1,10 @@
 use std::path::Path;
 
-use rand::rngs::OsRng;
-use rsa::{pkcs8, rand_core::CryptoRngCore, Pkcs1v15Encrypt, RsaPrivateKey, RsaPublicKey};
+use rsa::{
+    pkcs8,
+    rand_core::{CryptoRngCore, OsRng},
+    Pkcs1v15Encrypt, RsaPrivateKey, RsaPublicKey,
+};
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]