Update dependencies

Cargo.toml

@@ -12,24 +12,24 @@ license = "MIT"
 exclude = [".gitignore", ".github/*"]
 
 [dependencies]
-alloy-rlp = "0.3.9"
+alloy-rlp = "0.3.12"
 base64 = "0.22"
 bytes = "1"
 hex = "0.4"
 log = "0.4"
-rand = "0.8"
+rand = "0.9"
 zeroize = "1.8"
-sha3 = "0.10"
-k256 = { version = "0.13", features = ["ecdsa"], optional = true }
+sha3 = "0.11.0-rc.3"
+k256 = { version = "0.14.0-pre.10", features = ["ecdsa"], optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
-ed25519-dalek = { version = "2.1", optional = true, features = ["rand_core"] }
-secp256k1 = { version = "0.30", optional = true, default-features = false, features = [
+ed25519-dalek = { version = "3.0.0-pre.1", optional = true, features = ["rand_core"] }
+secp256k1 = { version = "0.31", optional = true, default-features = false, features = [
     "global-context",
 ] }
 
 [dev-dependencies]
 alloy-rlp = { version = "0.3", features = ["derive"] }
-secp256k1 = { version = "0.30", features = ["rand"] }
+secp256k1 = { version = "0.31", features = ["rand"] }
 serde_json = "1.0"
 
 [features]

README.md

@@ -60,10 +60,10 @@ enr = { version = "*", features = ["serde", "ed25519", "rust-secp256k1"] }
 ```rust
 use enr::{Enr, k256};
 use std::net::Ipv4Addr;
-use rand::thread_rng;
+use rand::rng;
 
 // generate a random secp256k1 key
-let mut rng = thread_rng();
+let mut rng = rng();
 let key = k256::ecdsa::SigningKey::random(&mut rng);
 
 let ip = Ipv4Addr::new(192,168,0,1);
@@ -103,13 +103,13 @@ can be added using `insert` and retrieved with `get`.
 ```rust
 use enr::{k256::ecdsa::SigningKey, Enr};
 use std::net::Ipv4Addr;
-use rand::thread_rng;
+use rand::rng;
 
 // specify the type of ENR
 type DefaultEnr = Enr<SigningKey>;
 
 // generate a random secp256k1 key
-let mut rng = thread_rng();
+let mut rng = rng();
 let key = SigningKey::random(&mut rng);
 
 let ip = Ipv4Addr::new(192,168,0,1);
@@ -136,10 +136,10 @@ assert_eq!(decoded_enr.get("custom_key").as_ref().map(AsRef::as_ref), Some(vec![
 ```rust
 use enr::{ed25519_dalek as ed25519, k256::ecdsa, CombinedKey, Enr};
 use std::net::Ipv4Addr;
-use rand::thread_rng;
+use rand::rng;
 
 // generate a random secp256k1 key
-let mut rng = thread_rng();
+let mut rng = rng();
 let key = ecdsa::SigningKey::random(&mut rng);
 let ip = Ipv4Addr::new(192, 168, 0, 1);
 let enr_secp256k1 = Enr::builder().ip4(ip).tcp4(8000).build(&key).unwrap();

src/keys/combined.rs

@@ -67,14 +67,14 @@ impl CombinedKey {
     /// Generates a new secp256k1 key.
     #[must_use]
     pub fn generate_secp256k1() -> Self {
-        let key = k256::ecdsa::SigningKey::random(&mut rand::thread_rng());
+        let key = k256::ecdsa::SigningKey::random(&mut rand::rng());
         Self::Secp256k1(key)
     }
 
     /// Generates a new ed25510 key.
     #[must_use]
     pub fn generate_ed25519() -> Self {
-        Self::Ed25519(ed25519::SigningKey::generate(&mut rand::thread_rng()))
+        Self::Ed25519(ed25519::SigningKey::generate(&mut rand::rng()))
     }
 
     /// Imports a secp256k1 from raw bytes in any format.

src/keys/k256_key.rs

@@ -28,9 +28,11 @@ impl EnrKey for SigningKey {
 
     fn sign_v4(&self, msg: &[u8]) -> Result<Vec<u8>, SigningError> {
         // take a keccak256 hash then sign.
-        let digest = Keccak256::new().chain_update(msg);
         let signature: Signature = self
-            .try_sign_digest_with_rng(&mut OsRng, digest)
+            .try_sign_digest_with_rng(&mut OsRng, |digest: &mut Keccak256| {
+                digest.update(msg);
+                Ok(())
+            })
             .map_err(|_| SigningError::new("failed to sign"))?;
 
         Ok(signature.to_vec())
@@ -67,7 +69,13 @@ impl EnrPublicKey for VerifyingKey {
     fn verify_v4(&self, msg: &[u8], sig: &[u8]) -> bool {
         if let Ok(sig) = k256::ecdsa::Signature::try_from(sig) {
             return self
-                .verify_digest(Keccak256::new().chain_update(msg), &sig)
+                .verify_digest(
+                    |digest: &mut Keccak256| {
+                        digest.update(msg);
+                        Ok(())
+                    },
+                    &sig,
+                )
                 .is_ok();
         }
         false

src/keys/rust_secp256k1.rs

@@ -2,14 +2,16 @@ use super::{EnrKey, EnrKeyUnambiguous, EnrPublicKey, SigningError};
 use crate::{digest, Key};
 use alloy_rlp::{Decodable, Error as DecoderError};
 use bytes::Bytes;
-use rand::RngCore;
+use rand::TryRngCore;
 use secp256k1::SECP256K1;
 use std::collections::BTreeMap;
 
 #[cfg(test)]
 use self::MockOsRng as OsRng;
 #[cfg(not(test))]
 use rand::rngs::OsRng;
+#[cfg(test)]
+use rand::RngCore;
 
 /// The ENR key that stores the public key in the ENR record.
 pub const ENR_KEY: &str = "secp256k1";
@@ -24,8 +26,10 @@ impl EnrKey for secp256k1::SecretKey {
         // serialize to an uncompressed 64 byte vector
         let signature = {
             let mut noncedata = [0; 32];
-            OsRng.fill_bytes(&mut noncedata);
-            SECP256K1.sign_ecdsa_with_noncedata(&m, self, &noncedata)
+            OsRng
+                .try_fill_bytes(&mut noncedata)
+                .map_err(|error| SigningError::new(format!("Failed to fill_bytes: {error}")))?;
+            SECP256K1.sign_ecdsa_with_noncedata(m, self, &noncedata)
         };
         Ok(signature.serialize_compact().to_vec())
     }
@@ -61,7 +65,7 @@ impl EnrPublicKey for secp256k1::PublicKey {
         let msg = digest(msg);
         if let Ok(sig) = secp256k1::ecdsa::Signature::from_compact(sig) {
             let msg = secp256k1::Message::from_digest(msg);
-            return SECP256K1.verify_ecdsa(&msg, &sig, self).is_ok();
+            return SECP256K1.verify_ecdsa(msg, &sig, self).is_ok();
         }
         false
     }
@@ -105,8 +109,4 @@ impl RngCore for MockOsRng {
         debug_assert_eq!(dest.len(), MOCK_ECDSA_NONCE_ADDITIONAL_DATA.len());
         dest.copy_from_slice(&MOCK_ECDSA_NONCE_ADDITIONAL_DATA);
     }
-
-    fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), rand::Error> {
-        unimplemented!();
-    }
 }