Merge 32db62e into 9e3a7c9

Author: fbozic

Cargo.lock

@@ -108,6 +108,11 @@ pub struct InitCommand {
     #[clap(overrides_with("mdns"))]
     pub no_mdns: bool,
 
+    /// Advertise observed address
+    #[clap(long, default_value_t = false)]
+    #[clap(overrides_with("no_mdns"))]
+    pub advertise_address: bool,
+
     #[clap(
         long,
         default_value = "3",
@@ -395,6 +400,7 @@ impl InitCommand {
                 BootstrapConfig::new(BootstrapNodes::new(boot_nodes)),
                 DiscoveryConfig::new(
                     mdns,
+                    self.advertise_address,
                     RendezvousConfig::new(self.rendezvous_registrations_limit),
                     RelayConfig::new(self.relay_registrations_limit),
                     AutonatConfig::new(self.autonat_confidence_threshold),

crates/merod/src/cli/init.rs

@@ -119,6 +119,8 @@ pub struct DiscoveryConfig {
     #[serde(default = "calimero_primitives::common::bool_true")]
     pub mdns: bool,
 
+    pub advertise_address: bool,
+
     pub rendezvous: RendezvousConfig,
 
     pub relay: RelayConfig,
@@ -130,12 +132,14 @@ impl DiscoveryConfig {
     #[must_use]
     pub const fn new(
         mdns: bool,
+        advertise_address: bool,
         rendezvous: RendezvousConfig,
         relay: RelayConfig,
         autonat: AutonatConfig,
     ) -> Self {
         Self {
             mdns,
+            advertise_address,
             rendezvous,
             relay,
             autonat,
@@ -147,6 +151,7 @@ impl Default for DiscoveryConfig {
     fn default() -> Self {
         Self {
             mdns: true,
+            advertise_address: false,
             rendezvous: RendezvousConfig::default(),
             relay: RelayConfig::default(),
             autonat: AutonatConfig::default(),

crates/network/src/config.rs

@@ -14,6 +14,7 @@ pub mod state;
 
 #[derive(Debug)]
 pub struct Discovery {
+    pub(crate) advertise_address: bool,
     pub(crate) state: DiscoveryState,
     pub(crate) rendezvous_config: RendezvousConfig,
     pub(crate) relay_config: RelayConfig,
@@ -22,11 +23,13 @@ pub struct Discovery {
 
 impl Discovery {
     pub(crate) fn new(
+        advertise_address: bool,
         rendezvous_config: &RendezvousConfig,
         relay_config: &RelayConfig,
         autonat_config: &AutonatConfig,
     ) -> Self {
         Self {
+            advertise_address,
             state: DiscoveryState::default(),
             rendezvous_config: rendezvous_config.clone(),
             relay_config: relay_config.clone(),
@@ -282,27 +285,28 @@ impl EventLoop {
         Ok(())
     }
 
-    // Add a peer to the list of servers that may be used for determining our NAT status.
-    // These peers are used for dial-request even if they are currently not connected,
-    // in which case a connection will be established before sending the dial-request.
-    pub(crate) fn add_autonat_server(&mut self, autonat_peer: &PeerId) -> EyreResult<()> {
-        let peer_info = self
-            .discovery
-            .state
-            .get_peer_info(autonat_peer)
-            .wrap_err("Failed to get peer info")?;
-
-        debug!(
-            %autonat_peer,
-            ?peer_info,
-            "Adding peer to the list of autonat servers"
-        );
-
-        self.swarm
-            .behaviour_mut()
-            .autonat
-            .add_server(*autonat_peer, None);
-
-        Ok(())
-    }
+    // TODO: Revisit AutoNAT protocol integration
+    // // Add a peer to the list of servers that may be used for determining our NAT status.
+    // // These peers are used for dial-request even if they are currently not connected,
+    // // in which case a connection will be established before sending the dial-request.
+    // pub(crate) fn add_autonat_server(&mut self, autonat_peer: &PeerId) -> EyreResult<()> {
+    //     let peer_info = self
+    //         .discovery
+    //         .state
+    //         .get_peer_info(autonat_peer)
+    //         .wrap_err("Failed to get peer info")?;
+
+    //     debug!(
+    //         %autonat_peer,
+    //         ?peer_info,
+    //         "Adding peer to the list of autonat servers"
+    //     );
+
+    //     self.swarm
+    //         .behaviour_mut()
+    //         .autonat
+    //         .add_server(*autonat_peer, None);
+
+    //     Ok(())
+    // }
 }

crates/network/src/discovery.rs

@@ -164,9 +164,10 @@ impl DiscoveryState {
         self.rendezvous_index.contains(peer_id)
     }
 
-    pub(crate) fn is_peer_autonat(&self, peer_id: &PeerId) -> bool {
-        self.autonat_index.contains(peer_id)
-    }
+    // TOOD: Revisit AutoNAT protocol integration
+    // pub(crate) fn is_peer_autonat(&self, peer_id: &PeerId) -> bool {
+    //     self.autonat_index.contains(peer_id)
+    // }
 
     #[expect(
         clippy::arithmetic_side_effects,

crates/network/src/discovery/state.rs

@@ -6,7 +6,7 @@
 use eyre::eyre;
 use libp2p::core::ConnectedPoint;
 use multiaddr::Protocol;
-use tracing::error;
+use tracing::{error, info};
 
 use super::*;
 use crate::discovery::state::{PeerDiscoveryMechanism, RelayReservationStatus};
@@ -148,26 +148,24 @@ impl EventLoop {
                 trace!("New external address candidate: {}", address);
             }
             SwarmEvent::ExternalAddrConfirmed { address } => {
-                debug!("External address confirmed: {}", address);
+                info!("External address confirmed: {}", address);
                 if let Ok(relayed_addr) = RelayedMultiaddr::try_from(&address) {
                     self.discovery.state.update_relay_reservation_status(
                         &relayed_addr.relay_peer,
                         RelayReservationStatus::Accepted,
                     );
-
-                    self.broadcast_rendezvous_registrations();
                 }
+                self.broadcast_rendezvous_registrations();
             }
             SwarmEvent::ExternalAddrExpired { address } => {
-                debug!("External address expired: {}", address);
+                info!("External address expired: {}", address);
                 if let Ok(relayed_addr) = RelayedMultiaddr::try_from(&address) {
                     self.discovery.state.update_relay_reservation_status(
                         relayed_addr.relay_peer_id(),
                         RelayReservationStatus::Expired,
                     );
-
-                    self.broadcast_rendezvous_registrations();
                 }
+                self.broadcast_rendezvous_registrations();
             }
             SwarmEvent::NewExternalAddrOfPeer { peer_id, address } => {
                 debug!("New external address of peer: {} {}", peer_id, address);

crates/network/src/events.rs

@@ -1,6 +1,6 @@
 use libp2p::identify::Event;
 use owo_colors::OwoColorize;
-use tracing::{debug, error};
+use tracing::{debug, error, info};
 
 use super::{EventHandler, EventLoop};
 
@@ -13,32 +13,28 @@ impl EventHandler<Event> for EventLoop {
                 .state
                 .update_peer_protocols(&peer_id, &info.protocols);
 
-            if self.discovery.state.is_peer_autonat(&peer_id) {
-                if let Err(err) = self.add_autonat_server(&peer_id) {
-                    error!(%err, "Failed to add autonat server");
-                };
-            }
+            // TODO: Revist AutoNAT protocol implementation
+            // if self.discovery.state.is_peer_autonat(&peer_id) {
+            //     if let Err(err) = self.add_autonat_server(&peer_id) {
+            //         error!(%err, "Failed to add autonat server");
+            //     };
+            // }
 
-            if self.discovery.state.is_peer_relay(&peer_id)
-                && self.discovery.state.is_autonat_status_private()
-            {
-                if let Err(err) = self.create_relay_reservation(&peer_id) {
-                    error!(%err, "Failed to handle relay reservation");
-                };
+            if self.discovery.advertise_address {
+                info!("Adding external address: {:?}", info.observed_addr);
+                self.swarm.add_external_address(info.observed_addr);
+            } else {
+                if self.discovery.state.is_peer_relay(&peer_id) {
+                    if let Err(err) = self.create_relay_reservation(&peer_id) {
+                        error!(%err, "Failed to handle relay reservation");
+                    };
+                }
             }
 
-            if self.discovery.state.is_peer_rendezvous(&peer_id)
-                && self.discovery.state.is_autonat_status_public()
-                && self.swarm.behaviour().autonat.confidence()
-                    >= self.discovery.autonat_config.confidence_threshold
-            {
+            if self.discovery.state.is_peer_rendezvous(&peer_id) {
                 if let Err(err) = self.rendezvous_discover(&peer_id) {
                     error!(%err, "Failed to perform rendezvous discovery");
                 };
-
-                if let Err(err) = self.rendezvous_register(&peer_id) {
-                    error!(%err, "Failed to update registration discovery");
-                };
             }
         }
     }

crates/network/src/events/identify.rs

@@ -183,6 +183,7 @@ fn init(
     };
 
     let discovery = Discovery::new(
+        config.discovery.advertise_address,
         &config.discovery.rendezvous,
         &config.discovery.relay,
         &config.discovery.autonat,

crates/network/src/lib.rs

@@ -8,8 +8,8 @@ license.workspace = true
 
 [dependencies]
 axum.workspace = true
-axum-server.workspace = true
-axum-server-dual-protocol.workspace = true
+# axum-server.workspace = true
+# axum-server-dual-protocol.workspace = true
 base64.workspace = true
 borsh = { workspace = true, features = ["derive"] }
 bs58.workspace = true

crates/server/Cargo.toml

@@ -1,12 +1,9 @@
 use core::net::{IpAddr, SocketAddr};
-use std::io::Error as IoError;
 use std::sync::Arc;
 
 use admin::storage::jwt_secret::get_or_create_jwt_secret;
 use axum::http::Method;
 use axum::Router;
-use axum_server::tls_rustls::RustlsConfig;
-use axum_server_dual_protocol::bind_dual_protocol;
 use calimero_context::ContextManager;
 use calimero_node_primitives::ServerSender;
 use calimero_primitives::events::NodeEvent;
@@ -22,7 +19,6 @@ use tower_http::cors::{Any, CorsLayer};
 use tracing::warn;
 
 use crate::admin::service::{setup, site};
-use crate::certificates::get_certificate;
 
 pub mod certificates;
 
@@ -167,34 +163,12 @@ pub async fn start(
             ])
             .allow_private_network(true),
     );
-    // Check if the certificate exists and if they contain the current local IP address
-    let (cert_pem, key_pem) = get_certificate(&store)?;
-
-    // Configure certificate and private key used by https
-    let rustls_config = match RustlsConfig::from_pem(cert_pem, key_pem).await {
-        Ok(config) => config,
-        Err(e) => {
-            eprintln!("Failed to load TLS configuration: {e:?}");
-            return Err(e.into());
-        }
-    };
 
     let mut set = JoinSet::new();
 
     for listener in listeners {
-        let rustls_config = rustls_config.clone();
         let app = app.clone();
-        let addr = listener.local_addr().unwrap();
-        drop(set.spawn(async move {
-            if let Err(e) = bind_dual_protocol(addr, rustls_config)
-                .serve(app.into_make_service())
-                .await
-            {
-                eprintln!("Server error: {e:?}");
-                return Err(e);
-            }
-            Ok::<(), IoError>(())
-        }));
+        drop(set.spawn(async move { axum::serve(listener, app).await }));
     }
 
     while let Some(result) = set.join_next().await {