Remove libp2p feature (#11)

* Remove libp2p feature

* Version bump & workflow correction

* Remove libp2p from readme

Author: AgeManning

.github/workflows/build.yml

@@ -47,12 +47,3 @@ jobs:
         run: rustup update stable
       - name: Run tests in release
         run: cargo test --all --release --no-default-features --features "libsecp256k1","ed25519" --tests
-  release-tests-ubuntu-libsecp256k1-ed25519-libp2p:
-    runs-on: ubuntu-latest
-    needs: cargo-fmt
-    steps:
-      - uses: actions/checkout@v2
-      - name: Get latest version of stable rust
-        run: rustup update stable
-      - name: Run tests in release
-        run: cargo test --all --release --no-default-features --features "libsecp256k1","ed25519","libp2p" --tests

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
+name = "enr"
 authors = ["Age Manning <[email protected]>"]
 edition = "2018"
-name = "enr"
-version = "0.1.0-alpha.5"
+version = "0.1.0-alpha.6"
 description = "Rust implementation of Ethereum Node Record (ENR) EIP778"
 readme = "./README.md"
 keywords = ["ethereum", "enr", "record", "EIP778", "node"]
@@ -34,7 +34,6 @@ c-secp256k1 = { package = "secp256k1", features = ["rand-std"], version = "0.17"
 
 [features]
 default = ["serde", "libsecp256k1" ]
-libp2p = ["libp2p-core"]
 ed25519 = ["ed25519-dalek"]
 rust-secp256k1 = ["c-secp256k1"]
 

README.md

@@ -39,24 +39,18 @@ Furthermore, a `CombinedKey` is provided if the `ed25519` feature flag is set, w
 ENR type that can support both `secp256k1` and `ed25519` signed ENR records. Examples of the
 use of each of these key types is given below.
 
-Additionally there is support for conversion of `rust-libp2p` `Keypair` to the `CombinedKey` type
-via the `libp2p` feature flag.
-
 ## Features
 
 This crate supports a number of features.
 
 - `serde`: Allows for serde serialization and deserialization for ENRs.
-- `libp2p`: Provides libp2p integration. Libp2p `Keypair`'s can be converted to `CombinedKey`
-types which can be used to sign and modify ENRs. This feature also adds the `peer_id()`
-and `multiaddr()` functions to an ENR which provides an ENR's associated `PeerId` and list of
-`MultiAddr`'s respectively.
 - `ed25519`: Provides support for `ed25519_dalek` keypair types.
+- `rust-secp256k1`: Uses `c-secp256k1` for secp256k1 keys.
 
 These can be enabled via adding the feature flag in your `Cargo.toml`
 
 ```toml
-enr = { version = "*", features = ["serde", "libp2p", "ed25519"] }
+enr = { version = "*", features = ["serde", "ed25519", "rust-secp256k1"] }
 ```
 
 ## Examples
@@ -136,24 +130,6 @@ assert_eq!(decoded_enr.tcp(), Some(8001));
 assert_eq!(decoded_enr.get("custom_key"), Some(&vec![0,0,1]));
 ```
 
-#### Libp2p key conversion, with the `libp2p` feature flag
-
-```rust
-use enr::{EnrBuilder, CombinedKey};
-use std::net::Ipv4Addr;
-use std::convert::TryInto;
-
-// with the `libp2p` feature flag, one can also use a libp2p key
-let libp2p_key = libp2p_core::identity::Keypair::generate_secp256k1();
-let key: CombinedKey = libp2p_key.try_into().expect("supports secp256k1");
-
-let ip = Ipv4Addr::new(192,168,0,1);
-let enr = EnrBuilder::new("v4").ip(ip.into()).tcp(8000).build(&key).unwrap();
-
-assert_eq!(enr.ip(), Some("192.168.0.1".parse().unwrap()));
-assert_eq!(enr.id(), Some("v4".into()));
-```
-
 #### Encoding/Decoding ENR's of various key types
 
 ```rust

src/keys/combined.rs

@@ -10,11 +10,6 @@ pub use secp256k1;
 use std::collections::BTreeMap;
 use zeroize::Zeroize;
 
-#[cfg(feature = "libp2p")]
-use libp2p_core::{identity::Keypair as Libp2pKeypair, PeerId};
-#[cfg(feature = "libp2p")]
-use std::convert::TryFrom;
-
 /// A standard implementation of the `EnrKey` trait used to sign and modify ENR records. The variants here represent the currently
 /// supported in-built signing schemes.
 pub enum CombinedKey {
@@ -44,27 +39,6 @@ impl From<ed25519::SecretKey> for CombinedKey {
     }
 }
 
-#[cfg(any(feature = "libp2p", doc))]
-impl TryFrom<Libp2pKeypair> for CombinedKey {
-    type Error = &'static str;
-
-    fn try_from(keypair: Libp2pKeypair) -> Result<Self, Self::Error> {
-        match keypair {
-            Libp2pKeypair::Secp256k1(key) => {
-                let secret = secp256k1::SecretKey::parse(&key.secret().to_bytes())
-                    .expect("libp2p key must be valid");
-                Ok(CombinedKey::Secp256k1(secret))
-            }
-            Libp2pKeypair::Ed25519(key) => {
-                let ed_keypair = ed25519::SecretKey::from_bytes(&key.encode()[..32])
-                    .expect("libp2p key must be valid");
-                Ok(CombinedKey::from(ed_keypair))
-            }
-            _ => Err("Unsupported key type"),
-        }
-    }
-}
-
 impl EnrKey for CombinedKey {
     type PublicKey = CombinedPublicKey;
 
@@ -178,44 +152,33 @@ impl EnrPublicKey for CombinedPublicKey {
     /// Verify a raw message, given a public key for the v4 identity scheme.
     fn verify_v4(&self, msg: &[u8], sig: &[u8]) -> bool {
         match self {
-            CombinedPublicKey::Secp256k1(pk) => pk.verify_v4(msg, sig),
-            CombinedPublicKey::Ed25519(pk) => pk.verify_v4(msg, sig),
+            Self::Secp256k1(pk) => pk.verify_v4(msg, sig),
+            Self::Ed25519(pk) => pk.verify_v4(msg, sig),
         }
     }
 
     /// Encodes the public key into compressed form, if possible.
     fn encode(&self) -> Vec<u8> {
         match self {
             // serialize in compressed form: 33 bytes
-            CombinedPublicKey::Secp256k1(pk) => pk.encode(),
-            CombinedPublicKey::Ed25519(pk) => pk.encode(),
+            Self::Secp256k1(pk) => pk.encode(),
+            Self::Ed25519(pk) => pk.encode(),
         }
     }
 
     /// Encodes the public key in uncompressed form.
     fn encode_uncompressed(&self) -> Vec<u8> {
         match self {
-            CombinedPublicKey::Secp256k1(pk) => pk.encode_uncompressed(),
-            CombinedPublicKey::Ed25519(pk) => pk.encode_uncompressed(),
+            Self::Secp256k1(pk) => pk.encode_uncompressed(),
+            Self::Ed25519(pk) => pk.encode_uncompressed(),
         }
     }
 
     /// Generates the ENR public key string associated with the key type.
     fn enr_key(&self) -> String {
         match self {
-            CombinedPublicKey::Secp256k1(key) => key.enr_key(),
-            CombinedPublicKey::Ed25519(key) => key.enr_key(),
-        }
-    }
-
-    #[cfg(any(feature = "libp2p", doc))]
-    /// Converts the publickey into a peer id, without consuming the key.
-    ///
-    /// This is only available with the `libp2p` feature flag.
-    fn into_peer_id(&self) -> PeerId {
-        match self {
-            CombinedPublicKey::Secp256k1(pk) => pk.into_peer_id(),
-            CombinedPublicKey::Ed25519(pk) => pk.into_peer_id(),
+            Self::Secp256k1(key) => key.enr_key(),
+            Self::Ed25519(key) => key.enr_key(),
         }
     }
 }

src/keys/ed25519.rs

@@ -1,6 +1,4 @@
 use super::{ed25519_dalek as ed25519, EnrKey, EnrPublicKey, SigningError};
-#[cfg(feature = "libp2p")]
-use libp2p_core::{PeerId, PublicKey as Libp2pPublicKey};
 use rlp::DecoderError;
 use std::collections::BTreeMap;
 
@@ -57,16 +55,4 @@ impl EnrPublicKey for ed25519::PublicKey {
     fn enr_key(&self) -> String {
         ENR_KEY.into()
     }
-
-    #[cfg(any(feature = "libp2p", doc))]
-    /// Converts the publickey into a peer id, without consuming the key.
-    ///
-    /// This is only available with the `libp2p` feature flag.
-    fn into_peer_id(&self) -> PeerId {
-        let pk_bytes = self.to_bytes();
-        let libp2p_pk = Libp2pPublicKey::Ed25519(
-            libp2p_core::identity::ed25519::PublicKey::decode(&pk_bytes).expect("valid public key"),
-        );
-        PeerId::from_public_key(libp2p_pk)
-    }
 }

src/keys/libsecp256k1.rs

@@ -2,8 +2,6 @@
 
 use super::{secp256k1, EnrKey, EnrPublicKey, SigningError};
 use crate::digest;
-#[cfg(feature = "libp2p")]
-use libp2p_core::{PeerId, PublicKey as Libp2pPublicKey};
 use rlp::DecoderError;
 use std::collections::BTreeMap;
 
@@ -75,17 +73,4 @@ impl EnrPublicKey for secp256k1::PublicKey {
     fn enr_key(&self) -> String {
         ENR_KEY.into()
     }
-
-    #[cfg(any(feature = "libp2p", doc))]
-    /// Converts the publickey into a peer id, without consuming the key.
-    ///
-    /// This is only available with the `libp2p` feature flag.
-    fn into_peer_id(&self) -> PeerId {
-        let pk_bytes = self.serialize_compressed();
-        let libp2p_pk = Libp2pPublicKey::Secp256k1(
-            libp2p_core::identity::secp256k1::PublicKey::decode(&pk_bytes)
-                .expect("valid public key"),
-        );
-        PeerId::from_public_key(libp2p_pk)
-    }
 }

src/keys/mod.rs

@@ -23,8 +23,6 @@ pub use c_secp256k1;
 pub use combined::{CombinedKey, CombinedPublicKey};
 #[cfg(any(feature = "ed25519", doc))]
 pub use ed25519_dalek;
-#[cfg(feature = "libp2p")]
-use libp2p_core::PeerId;
 #[cfg(any(feature = "libsecp256k1", doc))]
 pub use secp256k1;
 
@@ -69,12 +67,6 @@ pub trait EnrPublicKey {
     /// Returns the ENR key identifier for the public key type. For `secp256k1` keys this
     /// is `secp256k1`.
     fn enr_key(&self) -> String;
-
-    #[cfg(any(feature = "libp2p", doc))]
-    /// Converts an `EnrPublicKey` into a libp2p `PeerId`
-    ///
-    /// Only required with the `libp2p` feature flag.
-    fn into_peer_id(&self) -> PeerId;
 }
 
 /// An error during signing of a message.

src/keys/rust_secp256k1.rs

@@ -1,7 +1,5 @@
 use super::{EnrKey, EnrPublicKey, SigningError};
 use crate::digest;
-#[cfg(feature = "libp2p")]
-use libp2p_core::{PeerId, PublicKey as Libp2pPublicKey};
 use rlp::DecoderError;
 use std::collections::BTreeMap;
 
@@ -60,14 +58,4 @@ impl EnrPublicKey for c_secp256k1::PublicKey {
     fn enr_key(&self) -> String {
         ENR_KEY.into()
     }
-
-    #[cfg(any(feature = "libp2p", doc))]
-    fn into_peer_id(&self) -> PeerId {
-        let pk_bytes = self.serialize();
-        let libp2p_pk = Libp2pPublicKey::Secp256k1(
-            libp2p_core::identity::secp256k1::PublicKey::decode(&pk_bytes)
-                .expect("valid public key"),
-        );
-        PeerId::from_public_key(libp2p_pk)
-    }
 }