feat: [wip] add relay/ping

Author: varex83

Cargo.lock

@@ -23,6 +23,7 @@ license = "Apache-2.0"                                    # TODO(template) updat
 publish = false
 
 [workspace.dependencies]
+anyhow = "*" # for testing purposes only
 axum = "0.8.6"
 chrono = { version = "0.4", features = ["serde"] }
 hex = { version = "^0.4.3" }

Cargo.toml

@@ -18,6 +18,10 @@ tokio.workspace = true
 [dev-dependencies]
 charon-testutil.workspace = true
 vise-exporter.workspace = true
+anyhow.workspace = true
 
 [lints]
 workspace = true
+
+[features]
+mdns = ["libp2p/mdns"]

crates/charon-p2p/Cargo.toml

@@ -0,0 +1,139 @@
+#![allow(missing_docs)]
+
+use std::net::Ipv4Addr;
+
+use anyhow::Result;
+use charon_eth2::enr::{Record, with_ip_impl, with_tcp_impl, with_udp_impl};
+use charon_p2p::{
+    config::P2PConfig,
+    gater::ConnGater,
+    peer::peer_id_from_key,
+    p2p::{Node, NodeType, PlutoBehavior, PlutoBehaviorEvent},
+};
+use k256::elliptic_curve::rand_core::OsRng;
+use libp2p::{Multiaddr, futures::StreamExt, identify, swarm::SwarmEvent};
+use tokio::signal;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let key = k256::SecretKey::random(&mut OsRng);
+    let mut p2p: Node<PlutoBehavior> = Node::new(
+        P2PConfig::default(),
+        key.clone(),
+        ConnGater,
+        false,
+        NodeType::QUIC,
+        PlutoBehavior::new,
+    );
+
+    let swarm = &mut p2p.swarm;
+
+    // Get port from environment variable or default to 1050
+    let port = std::env::var("PORT")
+        .ok()
+        .and_then(|p| p.parse::<u16>().ok())
+        .unwrap_or(1050);
+
+    let enr = Record::new(
+        key.clone(),
+        vec![
+            with_tcp_impl(port),
+            with_udp_impl(port),
+            with_ip_impl(Ipv4Addr::new(0, 0, 0, 0)),
+        ],
+    )
+    .unwrap();
+
+    println!("ENR: {}", enr);
+
+    swarm.listen_on(format!("/ip4/0.0.0.0/udp/{}/quic-v1", port).parse()?)?;
+    swarm.listen_on(format!("/ip4/0.0.0.0/tcp/{}", port).parse()?)?;
+
+    // Fetch peers from CLI arguments (ENR strings)
+    // Usage: cargo run --example p2p -- <enr1> <enr2> ...
+    for enr_str in std::env::args().skip(1) {
+        match Record::try_from(enr_str.as_str()) {
+            Ok(enr) => {
+                println!("Adding peer: {:?}", enr);
+                // Extract public key and convert to PeerId
+                let Some(public_key) = enr.public_key else {
+                    eprintln!("ENR missing public key");
+                    continue;
+                };
+
+                let peer_id = match peer_id_from_key(public_key) {
+                    Ok(peer_id) => peer_id,
+                    Err(e) => {
+                        eprintln!("Failed to convert ENR public key to PeerId: {}", e);
+                        continue;
+                    }
+                };
+
+                // Extract IP and ports from ENR
+                let ip = enr.ip().unwrap_or(Ipv4Addr::new(0, 0, 0, 0));
+
+                // Try to add TCP address if available
+                let tcp_port = enr.tcp().unwrap_or(3610);
+                let udp_port = enr.udp().unwrap_or(3610);
+
+                if enr.tcp().is_none() && enr.udp().is_none() {
+                    eprintln!("ENR missing both TCP and UDP ports");
+                }
+
+                swarm.add_peer_address(peer_id, format!("/ip4/{}/udp/{}", ip, udp_port).parse().unwrap());
+                swarm.add_peer_address(peer_id, format!("/ip4/{}/tcp/{}", ip, tcp_port).parse().unwrap());
+            }
+            Err(e) => {
+                eprintln!("Failed to parse ENR: {} (error: {})", enr_str, e);
+            }
+        }
+    }
+
+    loop {
+        tokio::select! {
+            event = swarm.select_next_some() => match event {
+                SwarmEvent::Behaviour(PlutoBehaviorEvent::Relay(event)) => {
+                    println!("Got relay event: {:?}", event);
+                },
+                SwarmEvent::Behaviour(PlutoBehaviorEvent::Identify(identify::Event::Received {
+                    info: identify::Info { observed_addr, ..}, ..
+                })) => {
+                    println!("Address observed {}", observed_addr);
+                }
+                SwarmEvent::Behaviour(PlutoBehaviorEvent::Mdns(libp2p::mdns::Event::Discovered(nodes))) => {
+                    for node in nodes {
+                        println!("Discovered node: {:?}", node);
+                        swarm.dial(node.1).unwrap();
+                    }
+                }
+                SwarmEvent::NewListenAddr { address, .. } => {
+                    println!("Local node is listening on {address}");
+                }
+                SwarmEvent::Behaviour(PlutoBehaviorEvent::Ping(ping_event)) => {
+                    println!("Got ping event: {:?}", ping_event);
+                }
+                SwarmEvent::IncomingConnection { connection_id, local_addr, send_back_addr } => {
+                    println!("Incoming connection (id={connection_id}) from {:?} (send on {:?})", local_addr, send_back_addr);
+                }
+                SwarmEvent::IncomingConnectionError {peer_id,connection_id,error, local_addr, send_back_addr } => {
+                    println!("Incoming connection (id={connection_id}) error from {:?} (send on {:?} to {:?}): {:?}", peer_id, local_addr, send_back_addr, error);
+                }
+                event => {
+                    println!("{:?}", event);
+                }
+            },
+            _ = signal::ctrl_c() => {
+                println!("\nReceived Ctrl+C, shutting down gracefully...");
+
+                // Perform cleanup
+                let _ = swarm;
+                drop(p2p);
+
+                println!("Shutdown complete");
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}

crates/charon-p2p/examples/p2p.rs

@@ -0,0 +1,4 @@
+//! Gater is responsible for whitelisting / blacklisting peers
+
+/// todo: Temporary empty
+pub struct ConnGater;

crates/charon-p2p/src/gater.rs

@@ -16,3 +16,9 @@ pub mod config;
 
 /// Metrics.
 pub mod metrics;
+
+/// P2P.
+pub mod p2p;
+
+/// Gater
+pub mod gater;

crates/charon-p2p/src/lib.rs

@@ -0,0 +1,154 @@
+#![allow(missing_docs)]
+#![allow(dead_code)]
+#![allow(unused)]
+
+//! P2P core concepts
+
+use std::{sync::Once, time::Duration};
+
+use libp2p::{
+    Swarm, SwarmBuilder, identify,
+    identity::Keypair,
+    noise, ping, relay,
+    swarm::{NetworkBehaviour, SwarmEvent},
+    tcp, yamux,
+};
+
+use libp2p::mdns;
+
+use crate::{config::P2PConfig, gater::ConnGater};
+
+pub enum NodeType {
+    TCP,
+    QUIC,
+}
+
+#[derive(NetworkBehaviour)]
+pub struct PlutoBehavior {
+    pub relay: relay::Behaviour,
+    pub identify: identify::Behaviour,
+    pub ping: ping::Behaviour,
+    pub mdns: mdns::tokio::Behaviour,
+}
+
+pub trait LoopBehavior {
+    fn spawn_loop(&self) -> impl Future<Output = ()>;
+}
+
+impl LoopBehavior for Node<PlutoBehavior> {
+    async fn spawn_loop(&self) {}
+}
+
+impl PlutoBehavior {
+    pub fn new(key: &Keypair) -> Self {
+        Self {
+            relay: relay::Behaviour::new(key.public().to_peer_id(), Default::default()),
+            identify: identify::Behaviour::new(identify::Config::new(
+                "/pluto/1.0.0-alpha".into(),
+                key.public(),
+            )),
+            ping: ping::Behaviour::new(
+                ping::Config::new()
+                    .with_interval(Duration::from_secs(1))
+                    .with_timeout(Duration::from_secs(2)),
+            ),
+            mdns: mdns::tokio::Behaviour::new(mdns::Config::default(), key.public().to_peer_id())
+                .unwrap(),
+        }
+    }
+}
+
+pub struct Node<B: NetworkBehaviour> {
+    pub swarm: Swarm<B>,
+    pub callbacks: Vec<Box<dyn Fn(&SwarmEvent<B>) + Send + Sync>>,
+}
+
+impl<B: NetworkBehaviour> Node<B> {
+    pub fn new<F>(
+        cfg: P2PConfig,
+        key: k256::SecretKey,
+        conn_gater: ConnGater,
+        filter_private_addrs: bool,
+        node_type: NodeType,
+        behavior_fn: F,
+    ) -> Self
+    where
+        F: Fn(&Keypair) -> B,
+    {
+        match node_type {
+            NodeType::TCP => {
+                Self::new_with_tcp(cfg, key, conn_gater, filter_private_addrs, behavior_fn)
+            }
+            NodeType::QUIC => {
+                Self::new_with_quic(cfg, key, conn_gater, filter_private_addrs, behavior_fn)
+            }
+        }
+    }
+
+    pub fn new_with_quic<F>(
+        cfg: P2PConfig,
+        key: k256::SecretKey,
+        conn_gater: ConnGater,
+        filter_private_addrs: bool,
+        behavior_fn: F,
+    ) -> Self
+    where
+        F: Fn(&Keypair) -> B,
+    {
+        let mut der = key.to_sec1_der().unwrap();
+        let keypair = Keypair::secp256k1_from_der(&mut der).unwrap();
+
+        let mut swarm = SwarmBuilder::with_existing_identity(keypair.clone())
+            .with_tokio()
+            .with_tcp(
+                tcp::Config::default(),
+                noise::Config::new,
+                yamux::Config::default,
+            )
+            .unwrap()
+            .with_quic()
+            .with_behaviour(behavior_fn)
+            .unwrap()
+            .with_swarm_config(|cfg| cfg.with_idle_connection_timeout(Duration::from_secs(300)))
+            .build();
+
+        Node {
+            swarm,
+            callbacks: vec![],
+        }
+    }
+
+    pub fn new_with_tcp<F>(
+        cfg: P2PConfig,
+        key: k256::SecretKey,
+        conn_gater: ConnGater,
+        filter_private_addrs: bool,
+        behavior_fn: F,
+    ) -> Self
+    where
+        F: Fn(&Keypair) -> B,
+    {
+        let mut der = key.to_sec1_der().unwrap();
+        let keypair = Keypair::secp256k1_from_der(&mut der).unwrap();
+
+        let mut swarm = SwarmBuilder::with_existing_identity(keypair.clone())
+            .with_tokio()
+            .with_tcp(
+                tcp::Config::default(),
+                noise::Config::new,
+                yamux::Config::default,
+            )
+            .unwrap()
+            .with_behaviour(behavior_fn)
+            .unwrap()
+            .with_swarm_config(|cfg| cfg.with_idle_connection_timeout(Duration::from_secs(300)))
+            .build();
+
+        Node {
+            swarm,
+            callbacks: vec![],
+        }
+    }
+
+    pub fn add_callback(&mut self, callback: Box<dyn Fn(&SwarmEvent<B>) + Send + Sync>) {}
+}