feat: add behaviours module, add relay client support

Author: varex83

Cargo.lock

@@ -26,6 +26,7 @@ publish = false
 anyhow = "*" # for testing purposes only
 axum = "0.8.6"
 chrono = { version = "0.4", features = ["serde"] }
+clap = { version = "4.5.53", features = ["derive"] }
 hex = { version = "^0.4.3" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }

Cargo.toml

@@ -19,9 +19,15 @@ tokio.workspace = true
 charon-testutil.workspace = true
 vise-exporter.workspace = true
 anyhow.workspace = true
+clap.workspace = true
+charon-k1util.workspace = true
 
 [lints]
 workspace = true
 
 [features]
-mdns = ["libp2p/mdns"]
+mdns = ["libp2p/mdns"]
+
+[[example]]
+name = "p2p"
+required-features = ["mdns"]

crates/charon-p2p/Cargo.toml

@@ -1,115 +1,124 @@
-#![allow(missing_docs)]
-
-use std::net::Ipv4Addr;
+//! P2P example
+//!
+//! This example creates a Pluto P2P node and connects to a relay.
+//! Also, it discovers other Pluto nodes using mDNS (requires the `mdns`
+//! feature).
 
 use anyhow::Result;
-use charon_eth2::enr::{Record, with_ip_impl, with_tcp_impl, with_udp_impl};
+use charon_eth2::enr::Record;
 use charon_p2p::{
+    behaviours::pluto::{PlutoBehaviourEvent},
+    behaviours::pluto_mdns::{PlutoMdnsBehaviour, PlutoMdnsBehaviourEvent},
     config::P2PConfig,
     gater::ConnGater,
-    peer::peer_id_from_key,
-    p2p::{Node, NodeType, PlutoBehavior, PlutoBehaviorEvent},
+    p2p::{Node, NodeType},
 };
+use clap::Parser;
 use k256::elliptic_curve::rand_core::OsRng;
-use libp2p::{Multiaddr, futures::StreamExt, identify, swarm::SwarmEvent};
+use libp2p::{Multiaddr, futures::StreamExt, identify, multiaddr::Protocol, swarm::SwarmEvent};
 use tokio::signal;
 
+/// Command line arguments
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// The port to listen on
+    #[arg(short, long, default_value = "1050")]
+    pub port: u16,
+    /// The ENRs to listen on
+    #[arg(short, long)]
+    pub enrs: Vec<String>,
+    /// The relay URL to dial
+    #[arg(short, long)]
+    pub relay_url: Option<Multiaddr>,
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     let key = k256::SecretKey::random(&mut OsRng);
-    let mut p2p: Node<PlutoBehavior> = Node::new(
+    let mut p2p: Node<_> = 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;
-                    }
-                };
+        PlutoMdnsBehaviour::new,
+    )?;
 
-                // Extract IP and ports from ENR
-                let ip = enr.ip().unwrap_or(Ipv4Addr::new(0, 0, 0, 0));
+    let args = Args::parse();
 
-                // Try to add TCP address if available
-                let tcp_port = enr.tcp().unwrap_or(3610);
-                let udp_port = enr.udp().unwrap_or(3610);
+    let swarm = &mut p2p.swarm;
 
-                if enr.tcp().is_none() && enr.udp().is_none() {
-                    eprintln!("ENR missing both TCP and UDP ports");
+    let enr = Record::new(key.clone(), vec![])?;
+
+    if let Some(relay_url) = &args.relay_url {
+        swarm.dial(relay_url.clone())?;
+        println!("Dialed relay");
+        let mut learned_observed_addr = false;
+        let mut told_relay_observed_addr = false;
+
+        loop {
+            match swarm
+                .next()
+                .await
+                .ok_or(anyhow::anyhow!("Swarm event is None"))?
+            {
+                SwarmEvent::NewListenAddr { .. } => {}
+                SwarmEvent::Dialing { .. } => {}
+                SwarmEvent::ConnectionEstablished { .. } => {}
+                SwarmEvent::Behaviour(PlutoMdnsBehaviourEvent::Pluto(
+                    PlutoBehaviourEvent::Ping(_),
+                )) => {}
+                SwarmEvent::Behaviour(PlutoMdnsBehaviourEvent::Pluto(
+                    PlutoBehaviourEvent::Identify(identify::Event::Sent { .. }),
+                )) => {
+                    println!("Told relay its public address");
+                    told_relay_observed_addr = true;
                 }
-
-                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());
+                SwarmEvent::Behaviour(PlutoMdnsBehaviourEvent::Pluto(
+                    PlutoBehaviourEvent::Identify(identify::Event::Received {
+                        info: identify::Info { observed_addr, .. },
+                        ..
+                    }),
+                )) => {
+                    println!("Relay told us our observed address: {}", observed_addr);
+                    learned_observed_addr = true;
+                }
+                event => panic!("{event:?}"),
             }
-            Err(e) => {
-                eprintln!("Failed to parse ENR: {} (error: {})", enr_str, e);
+            if learned_observed_addr && told_relay_observed_addr {
+                break;
             }
         }
     }
 
+    println!("ENR: {}", enr);
+
+    swarm.listen_on(format!("/ip4/0.0.0.0/udp/{}/quic-v1", args.port).parse()?)?;
+    swarm.listen_on(format!("/ip4/0.0.0.0/tcp/{}", args.port).parse()?)?;
+    if let Some(relay_url) = args.relay_url {
+        swarm.listen_on(relay_url.with(Protocol::P2pCircuit))?;
+    }
+
     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, ..}, ..
-                })) => {
+                SwarmEvent::Behaviour(PlutoMdnsBehaviourEvent::Pluto(PlutoBehaviourEvent::Identify(identify::Event::Received { info: identify::Info { observed_addr, .. }, .. }))) => {
+                    swarm.add_external_address(observed_addr.clone());
                     println!("Address observed {}", observed_addr);
                 }
-                SwarmEvent::Behaviour(PlutoBehaviorEvent::Mdns(libp2p::mdns::Event::Discovered(nodes))) => {
+                SwarmEvent::Behaviour(PlutoMdnsBehaviourEvent::Pluto(PlutoBehaviourEvent::Relay(event))) => {
+                    println!("Got relay event: {:?}", event);
+                },
+                SwarmEvent::Behaviour(PlutoMdnsBehaviourEvent::Mdns(libp2p::mdns::Event::Discovered(nodes))) => {
                     for node in nodes {
                         println!("Discovered node: {:?}", node);
-                        swarm.dial(node.1).unwrap();
+                        swarm.dial(node.1)?;
                     }
                 }
                 SwarmEvent::NewListenAddr { address, .. } => {
                     println!("Local node is listening on {address}");
                 }
-                SwarmEvent::Behaviour(PlutoBehaviorEvent::Ping(ping_event)) => {
+                SwarmEvent::Behaviour(PlutoMdnsBehaviourEvent::Pluto(PlutoBehaviourEvent::Ping(ping_event))) => {
                     println!("Got ping event: {:?}", ping_event);
                 }
                 SwarmEvent::IncomingConnection { connection_id, local_addr, send_back_addr } => {

crates/charon-p2p/examples/p2p.rs

@@ -0,0 +1,9 @@
+//! Behaviours.
+#![allow(missing_docs)] // we need to allow missing docs for the derive macro
+
+/// Pluto behaviour.
+pub mod pluto;
+
+#[cfg(feature = "mdns")]
+/// Pluto Mdns behaviour.
+pub mod pluto_mdns;