feat: add relay server functionality

Cargo.toml

@@ -13,6 +13,7 @@ members = [
     "crates/charon-testutil",
     "crates/tracing",
     "crates/eth2api",
+    "crates/relay-server"
 ]
 resolver = "3"
 
@@ -28,9 +29,10 @@ alloy = { version = "1.3", features = ["essentials"] }
 built = { version = "0.8.0", features = ["git2", "chrono", "cargo-lock"] }
 blst = "0.3"
 anyhow = "1"
+axum = "0.8.6"
 cancellation = "0.1.0"
 chrono = { version = "0.4", features = ["serde"] }
-clap = { version = "4.5", features = ["derive", "env", "cargo"] }
+clap = { version = "4.5.53", features = ["derive", "env", "cargo"] }
 crossbeam = "0.8.4"
 backon = "1.6.0"
 hex = { version = "0.4.3" }
@@ -43,7 +45,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0" }
 thiserror = "2.0"
 tokio = { version = "1", features = ["full"] }
-tokio-util = { version = "0.7" }
+tokio-util = "0.7.11"
 libp2p = { version = "0.56", features = ["full", "secp256k1"] }
 url = "2.5"
 uuid = { version = "1.19", features = ["serde", "v4"] }
@@ -76,6 +78,7 @@ charon-k1util = { path = "crates/charon-k1util" }
 charon-p2p = { path = "crates/charon-p2p" }
 charon-testutil = { path = "crates/charon-testutil" }
 charon-tracing = { path = "crates/tracing" }
+charon-relay-server = { path = "crates/relay-server" }
 eth2api = { path = "crates/eth2api" }
 
 [workspace.lints.rust]

crates/charon-p2p/Cargo.toml

@@ -7,6 +7,7 @@ license.workspace = true
 publish.workspace = true
 
 [dependencies]
+axum.workspace = true
 chrono.workspace = true
 libp2p.workspace = true
 thiserror.workspace = true
@@ -15,8 +16,14 @@ charon-eth2.workspace = true
 charon-k1util.workspace = true
 vise.workspace = true
 tokio.workspace = true
+tokio-util.workspace = true
 rand.workspace = true
 tempfile.workspace = true
+charon-tracing.workspace = true
+tracing.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+charon-core.workspace = true
 
 [dev-dependencies]
 charon-testutil.workspace = true

crates/charon-p2p/examples/p2p.rs

@@ -12,7 +12,6 @@ use charon_p2p::{
         pluto_mdns::{PlutoMdnsBehaviour, PlutoMdnsBehaviourEvent},
     },
     config::P2PConfig,
-    gater::ConnGater,
     p2p::{Node, NodeType},
 };
 use clap::Parser;
@@ -40,7 +39,6 @@ async fn main() -> Result<()> {
     let mut p2p: Node<_> = Node::new(
         P2PConfig::default(),
         key.clone(),
-        ConnGater::new_open_gater(),
         false,
         NodeType::QUIC,
         PlutoMdnsBehaviour::new,

crates/charon-p2p/src/behaviours/pluto.rs

@@ -1,11 +1,12 @@
 //! Pluto behaviour.
 
-use std::time::Duration;
+use std::sync::LazyLock;
 
 use libp2p::{identify, identity::Keypair, ping, relay, swarm::NetworkBehaviour};
 
-use crate::gater::ConnGater;
+use crate::{config::default_ping_config, gater::ConnGater};
 
+/// Pluto network behaviour.
 #[derive(NetworkBehaviour)]
 pub struct PlutoBehaviour {
     /// Connection gater behaviour.
@@ -19,20 +20,80 @@ pub struct PlutoBehaviour {
 }
 
 impl PlutoBehaviour {
-    /// Creates a new Pluto behaviour.
+    /// Creates a new Pluto behaviour with default configuration.
     pub fn new(key: &Keypair, relay_client: relay::client::Behaviour) -> Self {
+        PlutoBehaviourBuilder::default().build(key, relay_client)
+    }
+
+    /// Returns a new builder for configuring a PlutoBehaviour.
+    pub fn builder() -> PlutoBehaviourBuilder {
+        PlutoBehaviourBuilder::default()
+    }
+}
+
+/// The default user agent for the Pluto network.
+pub static DEFAULT_USER_AGENT: LazyLock<String> =
+    LazyLock::new(|| format!("pluto/{}", *charon_core::version::VERSION));
+
+/// The default identify protocol for the Pluto network.
+pub static DEFAULT_IDENTIFY_PROTOCOL: LazyLock<String> =
+    LazyLock::new(|| format!("/pluto/{}", *charon_core::version::VERSION));
+
+/// Builder for [`PlutoBehaviour`].
+#[derive(Debug, Clone)]
+pub struct PlutoBehaviourBuilder {
+    gater: Option<ConnGater>,
+    identify_protocol: String,
+    user_agent: String,
+}
+
+impl Default for PlutoBehaviourBuilder {
+    fn default() -> Self {
         Self {
+            gater: None,
+            identify_protocol: DEFAULT_IDENTIFY_PROTOCOL.clone(),
+            user_agent: DEFAULT_USER_AGENT.clone(),
+        }
+    }
+}
+
+impl PlutoBehaviourBuilder {
+    /// Creates a new builder with default configuration.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Sets the connection gater.
+    pub fn with_gater(mut self, gater: ConnGater) -> Self {
+        self.gater = Some(gater);
+        self
+    }
+
+    /// Sets the identify protocol string.
+    pub fn with_identify_protocol(mut self, protocol: impl Into<String>) -> Self {
+        self.identify_protocol = protocol.into();
+        self
+    }
+
+    /// Sets the user agent string.
+    pub fn with_user_agent(mut self, user_agent: impl Into<String>) -> Self {
+        self.user_agent = user_agent.into();
+        self
+    }
+
+    /// Builds the [`PlutoBehaviour`] with the provided keypair and relay
+    /// client.
+    pub fn build(self, key: &Keypair, relay_client: relay::client::Behaviour) -> PlutoBehaviour {
+        PlutoBehaviour {
+            gater: self
+                .gater
+                .unwrap_or_else(|| ConnGater::new_conn_gater(vec![], vec![])),
             relay: relay_client,
-            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)),
+            identify: identify::Behaviour::new(
+                identify::Config::new(self.identify_protocol, key.public())
+                    .with_agent_version(self.user_agent),
             ),
-            gater: ConnGater::new_conn_gater(vec![], vec![]),
+            ping: ping::Behaviour::new(default_ping_config()),
         }
     }
 }