Update all base dependencies (#16)

AgeManning · May 25, 2023 · eab5df8 · eab5df8
1 parent 28d84e5
commit eab5df8
Show file tree

Hide file tree

Showing 5 changed files with 31 additions and 32 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "discv5-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "Simple CLI utility for creating and debugging discovery v5 servers"
 authors = ["Age Manning <Age@AgeManning.com>"]
 edition = "2018"
@@ -15,19 +15,20 @@ exclude = [
 ]
 
 [dependencies]
-discv5 = { version = "0.1", features = ["libp2p"] }
+discv5 = { version = "0.2", features = ["libp2p"] }
 sha2 = "0.10"
-libsecp256k1 = "0.3"
-libp2p-core = "0.25"
-clap = { version = "4.0", features = ["derive"] }
+libsecp256k1 = "0.7"
+libp2p-identity = { version = "0.1.2", features = ["secp256k1"] }
+libp2p-core = "0.39"
+clap = { version = "4.3", features = ["derive"] }
 hex = "0.4"
 log = "0.4"
-simple_logger = "4.0"
+simple_logger = "4.1"
 futures = "0.3"
 tokio = { version = "1", features = ["full"] }
 eyre = "0.6.8"
-serde = "1.0.149"
-serde_json = "1.0.89"
+serde = "1.0.163"
+serde_json = "1.0.96"
 
 [[bin]]
 name = "discv5-cli"

diff --git a/src/packet/mod.rs b/src/packet/mod.rs
@@ -15,7 +15,7 @@ pub fn decode(decode: &Decode) {
 
     log::info!("Using decoding node id: {}", node_id);
 
-    match discv5::packet::Packet::decode(&node_id, &packet_bytes) {
+    match discv5::packet::Packet::decode::<discv5::DefaultProtocolId>(&node_id, &packet_bytes) {
         Ok(p) => log::info!("Packet decoded: {:?}", p),
         Err(e) => log::error!("Packet failed to be decoded. Error: {:?}", e),
     }

diff --git a/src/request_enr/enr_ext.rs b/src/request_enr/enr_ext.rs
@@ -1,5 +1,6 @@
 use discv5::enr::{CombinedKey, CombinedPublicKey};
-use libp2p_core::{identity::Keypair, multiaddr::Protocol, Multiaddr, PeerId};
+use libp2p_core::{multiaddr::Protocol, Multiaddr};
+use libp2p_identity::{Keypair, PeerId};
 
 type Enr = discv5::enr::Enr<CombinedKey>;
 
@@ -82,40 +83,37 @@ impl CombinedKeyPublicExt for CombinedPublicKey {
         match self {
             Self::Secp256k1(pk) => {
                 let pk_bytes = pk.to_bytes();
-                let libp2p_pk = libp2p_core::PublicKey::Secp256k1(
-                    libp2p_core::identity::secp256k1::PublicKey::decode(&pk_bytes)
+                let libp2p_pk = libp2p_identity::PublicKey::from(
+                    libp2p_identity::secp256k1::PublicKey::try_from_bytes(&pk_bytes)
                         .expect("valid public key"),
                 );
-                PeerId::from_public_key(libp2p_pk)
+                PeerId::from_public_key(&libp2p_pk)
             }
             Self::Ed25519(pk) => {
                 let pk_bytes = pk.to_bytes();
-                let libp2p_pk = libp2p_core::PublicKey::Ed25519(
-                    libp2p_core::identity::ed25519::PublicKey::decode(&pk_bytes)
+                let libp2p_pk = libp2p_identity::PublicKey::from(
+                    libp2p_identity::ed25519::PublicKey::try_from_bytes(&pk_bytes)
                         .expect("valid public key"),
                 );
-                PeerId::from_public_key(libp2p_pk)
+                PeerId::from_public_key(&libp2p_pk)
             }
         }
     }
 }
 
 impl CombinedKeyExt for CombinedKey {
     fn from_libp2p(key: &Keypair) -> Result<CombinedKey, &'static str> {
-        match key {
-            Keypair::Secp256k1(key) => {
-                let secret =
-                    discv5::enr::k256::ecdsa::SigningKey::from_bytes(&key.secret().to_bytes())
-                        .expect("libp2p key must be valid");
-                Ok(CombinedKey::Secp256k1(secret))
-            }
-            Keypair::Ed25519(key) => {
-                let ed_keypair =
-                    discv5::enr::ed25519_dalek::SecretKey::from_bytes(&key.encode()[..32])
-                        .expect("libp2p key must be valid");
-                Ok(CombinedKey::from(ed_keypair))
-            }
-            _ => Err("ENR: Unsupported libp2p key type"),
+        if let Ok(key) = key.clone().try_into_secp256k1() {
+            let secret = discv5::enr::k256::ecdsa::SigningKey::from_bytes(&key.secret().to_bytes())
+                .expect("libp2p key must be valid");
+            Ok(CombinedKey::Secp256k1(secret))
+        } else if let Ok(key) = key.clone().try_into_ed25519() {
+            let ed_keypair =
+                discv5::enr::ed25519_dalek::SecretKey::from_bytes(&key.to_bytes()[..32])
+                    .expect("libp2p key must be valid");
+            Ok(CombinedKey::from(ed_keypair))
+        } else {
+            Err("ENR: Unsupported libp2p key type")
         }
     }
 }
diff --git a/src/request_enr/mod.rs b/src/request_enr/mod.rs
@@ -33,7 +33,7 @@ pub async fn run(req: &RequestEnr) {
     // Construct the discv5 service
     let listen_socket = std::net::SocketAddr::new(listen_address, listen_port);
     let config = discv5::Discv5ConfigBuilder::new().build();
-    let mut discv5 = discv5::Discv5::new(enr, enr_key, config).unwrap();
+    let mut discv5: discv5::Discv5 = discv5::Discv5::new(enr, enr_key, config).unwrap();
 
     // Start the server
     discv5.start(listen_socket).await.unwrap();

diff --git a/tests/packet.rs b/tests/packet.rs
@@ -12,6 +12,6 @@ pub fn test_packet_decoding() {
     println!("Destination node id: {hex_dest_node_id:?}");
 
     let packet = discv5_packet::Packet::new_random(&source_node_id).unwrap();
-    let encoded = hex::encode(packet.encode(&dest_node_id));
+    let encoded = hex::encode(packet.encode::<discv5::DefaultProtocolId>(&dest_node_id));
     println!("Packet as hex: 0x{encoded:?}");
 }