refactor for removing Discv5 prefix

README.md

@@ -19,10 +19,10 @@ Status]][Crates Link]
 This is a rust implementation of the [Discovery v5](https:/ethereum/devp2p/blob/master/discv5/discv5.md)
 peer discovery protocol.
 
-Discovery v5 is a protocol designed for encrypted peer discovery (and topic advertisement tba). Each peer/node
-on the network is identified via it's `ENR` ([Ethereum Node
-Record](https://eips.ethereum.org/EIPS/eip-778)), which is essentially a signed key-value store
-containing the node's public key and optionally IP address and port.
+Discovery v5 is a protocol designed for encrypted peer discovery. Each peer/node on the network is
+identified via it's `ENR` ([Ethereum Node Record](https://eips.ethereum.org/EIPS/eip-778)), which
+is essentially a signed key-value store containing the node's public key and optionally IP address
+and port.
 
 Discv5 employs a kademlia-like routing table to store and manage discovered peers and topics. The
 protocol allows for external IP discovery in NAT environments through regular PING/PONG's with
@@ -37,7 +37,7 @@ For a simple CLI discovery service see [discv5-cli](https:/AgeMannin
 A simple example of creating this service is as follows:
 
 ```rust
- use discv5::{enr, enr::{CombinedKey, NodeId}, TokioExecutor, Discv5, Discv5ConfigBuilder};
+ use discv5::{enr, enr::{CombinedKey, NodeId}, TokioExecutor, Discv5, ConfigBuilder};
  use discv5::socket::ListenConfig;
  use std::net::SocketAddr;
 
@@ -59,7 +59,7 @@ A simple example of creating this service is as follows:
  };
 
  // default configuration
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  // construct the discv5 server
  let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();

examples/custom_executor.rs

@@ -9,7 +9,7 @@
 //! $ cargo run --example custom_executor <BASE64ENR>
 //! ```
 
-use discv5::{enr, enr::CombinedKey, Discv5, Discv5ConfigBuilder, Discv5Event, ListenConfig};
+use discv5::{enr, enr::CombinedKey, ConfigBuilder, Discv5, Event, ListenConfig};
 use std::net::Ipv4Addr;
 
 fn main() {
@@ -39,7 +39,7 @@ fn main() {
  .unwrap();
 
  // default configuration - uses the current executor
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  // construct the discv5 server
  let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
@@ -72,10 +72,10 @@ fn main() {
 
  loop {
  match event_stream.recv().await {
- Some(Discv5Event::SocketUpdated(addr)) => {
+ Some(Event::SocketUpdated(addr)) => {
  println!("Nodes ENR socket address has been updated to: {addr:?}");
  }
- Some(Discv5Event::Discovered(enr)) => {
+ Some(Event::Discovered(enr)) => {
  println!("A peer has been discovered: {}", enr.node_id());
  }
  _ => {}

examples/find_nodes.rs

@@ -19,7 +19,7 @@ use clap::Parser;
 use discv5::{
  enr,
  enr::{k256, CombinedKey},
- Discv5, Discv5ConfigBuilder, Discv5Event, ListenConfig,
+ ConfigBuilder, Discv5, Event, ListenConfig,
 };
 use std::{
  net::{IpAddr, Ipv4Addr, Ipv6Addr},
@@ -120,10 +120,10 @@ async fn main() {
  };
 
  // default configuration with packet filtering
- // let config = Discv5ConfigBuilder::new(listen_config).enable_packet_filter().build();
+ // let config = ConfigBuilder::new(listen_config).enable_packet_filter().build();
 
  // default configuration without packet filtering
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  info!("Node Id: {}", enr.node_id());
  if args.enr_ip6.is_some() || args.enr_ip4.is_some() {
@@ -192,12 +192,12 @@ async fn main() {
  continue;
  }
  match discv5_ev {
- Discv5Event::Discovered(enr) => info!("Enr discovered {}", enr),
- Discv5Event::EnrAdded { enr, replaced: _ } => info!("Enr added {}", enr),
- Discv5Event::NodeInserted { node_id, replaced: _ } => info!("Node inserted {}", node_id),
- Discv5Event::SessionEstablished(enr, _) => info!("Session established {}", enr),
- Discv5Event::SocketUpdated(addr) => info!("Socket updated {}", addr),
- Discv5Event::TalkRequest(_) => info!("Talk request received"),
+ Event::Discovered(enr) => info!("Enr discovered {}", enr),
+ Event::EnrAdded { enr, replaced: _ } => info!("Enr added {}", enr),
+ Event::NodeInserted { node_id, replaced: _ } => info!("Node inserted {}", node_id),
+ Event::SessionEstablished(enr, _) => info!("Session established {}", enr),
+ Event::SocketUpdated(addr) => info!("Socket updated {}", addr),
+ Event::TalkRequest(_) => info!("Talk request received"),
  };
  }
  }

examples/request_enr.rs

@@ -13,7 +13,7 @@
 //!
 //! This requires the "libp2p" feature.
 #[cfg(feature = "libp2p")]
-use discv5::Discv5ConfigBuilder;
+use discv5::ConfigBuilder;
 #[cfg(feature = "libp2p")]
 use discv5::ListenConfig;
 #[cfg(feature = "libp2p")]
@@ -46,7 +46,7 @@ async fn main() {
  let enr = enr::EnrBuilder::new("v4").build(&enr_key).unwrap();
 
  // default discv5 configuration
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  let multiaddr = std::env::args()
  .nth(1)

examples/simple_server.rs

@@ -10,7 +10,7 @@
 //! $ cargo run --example simple_server -- <ENR-IP> <ENR-PORT> <BASE64ENR>
 //! ```
 
-use discv5::{enr, enr::CombinedKey, Discv5, Discv5ConfigBuilder, Discv5Event, ListenConfig};
+use discv5::{enr, enr::CombinedKey, ConfigBuilder, Discv5, Event, ListenConfig};
 use std::net::Ipv4Addr;
 
 #[tokio::main]
@@ -72,7 +72,7 @@ async fn main() {
  }
 
  // default configuration
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  // construct the discv5 server
  let mut discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
@@ -104,10 +104,10 @@ async fn main() {
 
  loop {
  match event_stream.recv().await {
- Some(Discv5Event::SocketUpdated(addr)) => {
+ Some(Event::SocketUpdated(addr)) => {
  println!("Nodes ENR socket address has been updated to: {addr:?}");
  }
- Some(Discv5Event::Discovered(enr)) => {
+ Some(Event::Discovered(enr)) => {
  println!("A peer has been discovered: {}", enr.node_id());
  }
  _ => {}

src/config.rs

@@ -7,7 +7,7 @@ use std::time::Duration;
 
 /// Configuration parameters that define the performance of the discovery network.
 #[derive(Clone)]
-pub struct Discv5Config {
+pub struct Config {
  /// Whether to enable the incoming packet filter. Default: false.
  pub enable_packet_filter: bool,
 
@@ -101,11 +101,11 @@ pub struct Discv5Config {
 }
 
 #[derive(Debug)]
-pub struct Discv5ConfigBuilder {
- config: Discv5Config,
+pub struct ConfigBuilder {
+ config: Config,
 }
 
-impl Discv5ConfigBuilder {
+impl ConfigBuilder {
  pub fn new(listen_config: ListenConfig) -> Self {
  // This is only applicable if enable_packet_filter is set.
  let filter_rate_limiter = Some(
@@ -118,7 +118,7 @@ impl Discv5ConfigBuilder {
  );
 
  // set default values
- let config = Discv5Config {
+ let config = Config {
  enable_packet_filter: false,
  request_timeout: Duration::from_secs(1),
  vote_duration: Duration::from_secs(30),
@@ -145,7 +145,7 @@ impl Discv5ConfigBuilder {
  listen_config,
  };
 
- Discv5ConfigBuilder { config }
+ ConfigBuilder { config }
  }
 
  /// Whether to enable the incoming packet filter.
@@ -302,7 +302,7 @@ impl Discv5ConfigBuilder {
  self
  }
 
- pub fn build(&mut self) -> Discv5Config {
+ pub fn build(&mut self) -> Config {
  // If an executor is not provided, assume a current tokio runtime is running.
  if self.config.executor.is_none() {
  self.config.executor = Some(Box::<crate::executor::TokioExecutor>::default());
@@ -314,9 +314,9 @@ impl Discv5ConfigBuilder {
  }
 }
 
-impl std::fmt::Debug for Discv5Config {
+impl std::fmt::Debug for Config {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- f.debug_struct("Discv5Config")
+ f.debug_struct("Config")
  .field("filter_enabled", &self.enable_packet_filter)
  .field("request_timeout", &self.request_timeout)
  .field("vote_duration", &self.vote_duration)

src/discv5.rs

@@ -2,9 +2,9 @@
 //!
 //! This provides the main struct for running and interfacing with a discovery v5 server.
 //!
-//! A [`Discv5`] struct needs to be created either with an [`crate::executor::Executor`] specified in the
-//! [`Discv5Config`] via the [`crate::Discv5ConfigBuilder`] or in the presence of a tokio runtime that has
-//! timing and io enabled.
+//! A [`Discv5`] struct needs to be created either with an [`crate::executor::Executor`] specified
+//! in the [`Config`] via the [`crate::ConfigBuilder`] or in the presence of a tokio runtime that
+//! has timing and io enabled.
 //!
 //! Once a [`Discv5`] struct has been created the service is started by running the [`Discv5::start`]
 //! functions with a UDP socket. This will start a discv5 server in the background listening on the
@@ -13,15 +13,15 @@
 //! The server can be shutdown using the [`Discv5::shutdown`] function.
 
 use crate::{
- error::{Discv5Error, QueryError, RequestError},
+ error::{Error, QueryError, RequestError},
  kbucket::{
  self, ConnectionDirection, ConnectionState, FailureReason, InsertResult, KBucketsTable,
  NodeStatus, UpdateResult,
  },
  node_info::NodeContact,
  packet::ProtocolIdentity,
  service::{QueryKind, Service, ServiceRequest, TalkRequest},
- DefaultProtocolId, Discv5Config, Enr, IpMode,
+ Config, DefaultProtocolId, Enr, IpMode,
 };
 use enr::{CombinedKey, EnrError, EnrKey, NodeId};
 use parking_lot::RwLock;
@@ -53,7 +53,7 @@ mod test;
 
 /// Events that can be produced by the `Discv5` event stream.
 #[derive(Debug)]
-pub enum Discv5Event {
+pub enum Event {
  /// A node has been discovered from a FINDNODES request.
  ///
  /// The ENR of the node is returned. Various properties can be derived from the ENR.
@@ -81,7 +81,7 @@ pub struct Discv5<P = DefaultProtocolId>
 where
  P: ProtocolIdentity,
 {
- config: Discv5Config,
+ config: Config,
  /// The channel to make requests from the main service.
  service_channel: Option<mpsc::Sender<ServiceRequest>>,
  /// The exit channel to shutdown the underlying service.
@@ -102,7 +102,7 @@ impl<P: ProtocolIdentity> Discv5<P> {
  pub fn new(
  local_enr: Enr,
  enr_key: CombinedKey,
- mut config: Discv5Config,
+ mut config: Config,
  ) -> Result<Self, &'static str> {
  // ensure the keypair matches the one that signed the enr.
  if local_enr.public_key() != enr_key.public() {
@@ -154,10 +154,10 @@ impl<P: ProtocolIdentity> Discv5<P> {
  }
 
  /// Starts the required tasks and begins listening on a given UDP SocketAddr.
- pub async fn start(&mut self) -> Result<(), Discv5Error> {
+ pub async fn start(&mut self) -> Result<(), Error> {
  if self.service_channel.is_some() {
  warn!("Service is already started");
- return Err(Discv5Error::ServiceAlreadyStarted);
+ return Err(Error::ServiceAlreadyStarted);
  }
 
  // create the main service
@@ -670,7 +670,7 @@ impl<P: ProtocolIdentity> Discv5<P> {
  /// Creates an event stream channel which can be polled to receive Discv5 events.
  pub fn event_stream(
  &self,
- ) -> impl Future<Output = Result<mpsc::Receiver<Discv5Event>, Discv5Error>> + 'static {
+ ) -> impl Future<Output = Result<mpsc::Receiver<Event>, Error>> + 'static {
  let channel = self.clone_channel();
 
  async move {
@@ -682,20 +682,18 @@ impl<P: ProtocolIdentity> Discv5<P> {
  channel
  .send(event)
  .await
- .map_err(|_| Discv5Error::ServiceChannelClosed)?;
+ .map_err(|_| Error::ServiceChannelClosed)?;
 
- callback_recv
- .await
- .map_err(|_| Discv5Error::ServiceChannelClosed)
+ callback_recv.await.map_err(|_| Error::ServiceChannelClosed)
  }
  }
 
  /// Internal helper function to send events to the Service.
- fn clone_channel(&self) -> Result<mpsc::Sender<ServiceRequest>, Discv5Error> {
+ fn clone_channel(&self) -> Result<mpsc::Sender<ServiceRequest>, Error> {
  if let Some(channel) = self.service_channel.as_ref() {
  Ok(channel.clone())
  } else {
- Err(Discv5Error::ServiceNotStarted)
+ Err(Error::ServiceNotStarted)
  }
  }
 }

src/discv5/test.rs

@@ -26,7 +26,7 @@ async fn build_nodes(n: usize, base_port: u16) -> Vec<Discv5> {
  for port in base_port..base_port + n as u16 {
  let enr_key = CombinedKey::generate_secp256k1();
  let listen_config = ListenConfig::Ipv4 { ip, port };
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  let enr = EnrBuilder::new("v4")
  .ip4(ip)
@@ -50,7 +50,7 @@ async fn build_nodes_from_keypairs(keys: Vec<CombinedKey>, base_port: u16) -> Ve
  let port = base_port + i as u16;
 
  let listen_config = ListenConfig::Ipv4 { ip, port };
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  let enr = EnrBuilder::new("v4")
  .ip4(ip)
@@ -75,7 +75,7 @@ async fn build_nodes_from_keypairs_ipv6(keys: Vec<CombinedKey>, base_port: u16)
  ip: Ipv6Addr::LOCALHOST,
  port,
  };
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  let enr = EnrBuilder::new("v4")
  .ip6(Ipv6Addr::LOCALHOST)
@@ -106,7 +106,7 @@ async fn build_nodes_from_keypairs_dual_stack(
  ipv6: Ipv6Addr::LOCALHOST,
  ipv6_port,
  };
- let config = Discv5ConfigBuilder::new(listen_config).build();
+ let config = ConfigBuilder::new(listen_config).build();
 
  let enr = EnrBuilder::new("v4")
  .ip4(Ipv4Addr::LOCALHOST)
@@ -753,7 +753,7 @@ async fn test_table_limits() {
  ip: enr.ip4().unwrap(),
  port: enr.udp4().unwrap(),
  };
- let config = Discv5ConfigBuilder::new(listen_config).ip_limit().build();
+ let config = ConfigBuilder::new(listen_config).ip_limit().build();
 
  // let socket_addr = enr.udp_socket().unwrap();
  let discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
@@ -822,7 +822,7 @@ async fn test_bucket_limits() {
  ip: enr.ip4().unwrap(),
  port: enr.udp4().unwrap(),
  };
- let config = Discv5ConfigBuilder::new(listen_config).ip_limit().build();
+ let config = ConfigBuilder::new(listen_config).ip_limit().build();
 
  let discv5: Discv5 = Discv5::new(enr, enr_key, config).unwrap();
  for enr in enrs {