chore: switch to public_addresses

Signed-off-by: Simon Paitrault <[email protected]>

crates/topos-p2p/src/client.rs

@@ -23,13 +23,6 @@ pub struct NetworkClient {
 }
 
 impl NetworkClient {
-    pub async fn start_listening(&self, peer_addr: libp2p::Multiaddr) -> Result<(), P2PError> {
-        let (sender, receiver) = oneshot::channel();
-        let command = Command::StartListening { peer_addr, sender };
-
-        Self::send_command_with_receiver(&self.sender, command, receiver).await
-    }
-
     pub async fn connected_peers(&self) -> Result<Vec<PeerId>, P2PError> {
         let (sender, receiver) = oneshot::channel();
         Self::send_command_with_receiver(&self.sender, Command::ConnectedPeers { sender }, receiver)

crates/topos-p2p/src/command.rs

@@ -10,12 +10,6 @@ use crate::{
 
 #[derive(Debug)]
 pub enum Command {
-    /// Executed when the node is starting
-    StartListening {
-        peer_addr: Multiaddr,
-        sender: oneshot::Sender<Result<(), P2PError>>,
-    },
-
     /// Command to ask for the current connected peer id list
     ConnectedPeers {
         sender: oneshot::Sender<Result<Vec<PeerId>, P2PError>>,
@@ -56,7 +50,6 @@ pub enum Command {
 impl Display for Command {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Command::StartListening { .. } => write!(f, "StartListening"),
             Command::ConnectedPeers { .. } => write!(f, "ConnectedPeers"),
             Command::RandomKnownPeer { .. } => write!(f, "RandomKnownPeer"),
             Command::Disconnect { .. } => write!(f, "Disconnect"),

crates/topos-p2p/src/error.rs

@@ -42,8 +42,8 @@ pub enum P2PError {
     #[error("Unable to create gRPC client")]
     UnableToCreateGrpcClient(#[from] OutboundConnectionError),
 
-    #[error("Advertised addresses is empty")]
-    MissingAdvertisedAddresses,
+    #[error("Public addresses is empty")]
+    MissingPublicAddresses,
 }
 
 #[derive(Error, Debug)]

crates/topos-p2p/src/network.rs

@@ -40,7 +40,7 @@ pub struct NetworkBuilder<'a> {
     discovery_protocol: Option<&'static str>,
     peer_key: Option<Keypair>,
     listen_addresses: Option<Vec<Multiaddr>>,
-    advertised_addresses: Option<Vec<Multiaddr>>,
+    public_addresses: Option<Vec<Multiaddr>>,
     store: Option<MemoryStore>,
     known_peers: &'a [(PeerId, Multiaddr)],
     local_port: Option<u8>,
@@ -79,8 +79,8 @@ impl<'a> NetworkBuilder<'a> {
         self
     }
 
-    pub fn advertised_addresses(mut self, addresses: Vec<Multiaddr>) -> Self {
-        self.advertised_addresses = Some(addresses);
+    pub fn public_addresses(mut self, addresses: Vec<Multiaddr>) -> Self {
+        self.public_addresses = Some(addresses);
 
         self
     }
@@ -174,9 +174,9 @@ impl<'a> NetworkBuilder<'a> {
         let listen_addr = self
             .listen_addresses
             .take()
-            .expect("Node cannot listen for connection on empty address");
+            .expect("Node requires at least one address to listen for incoming connections");
 
-        let advertised_addresses = if let Some(addresses) = self.advertised_addresses.take() {
+        let public_addresses = if let Some(addresses) = self.public_addresses.take() {
             if addresses.is_empty() {
                 listen_addr.clone()
             } else {
@@ -204,7 +204,7 @@ impl<'a> NetworkBuilder<'a> {
                 event_sender,
                 local_peer_id: peer_id,
                 listening_on: listen_addr,
-                advertised_addresses,
+                public_addresses,
                 bootstrapped: false,
                 active_listeners: HashSet::new(),
                 pending_record_requests: HashMap::new(),

crates/topos-p2p/src/runtime/handle_command.rs

@@ -26,11 +26,6 @@ impl Runtime {
 
                 _ = response.send(connection);
             }
-            Command::StartListening { peer_addr, sender } => {
-                if sender.send(self.start_listening(peer_addr)).is_err() {
-                    warn!("Unable to notify StartListening response: initiator is dropped");
-                }
-            }
 
             Command::ConnectedPeers { sender } => {
                 if sender

crates/topos-p2p/src/runtime/mod.rs

@@ -27,7 +27,7 @@ pub struct Runtime {
     pub(crate) event_sender: mpsc::Sender<Event>,
     pub(crate) local_peer_id: PeerId,
     pub(crate) listening_on: Vec<Multiaddr>,
-    pub(crate) advertised_addresses: Vec<Multiaddr>,
+    pub(crate) public_addresses: Vec<Multiaddr>,
     pub(crate) bootstrapped: bool,
     pub(crate) is_boot_node: bool,
 
@@ -45,13 +45,6 @@ mod handle_command;
 mod handle_event;
 
 impl Runtime {
-    fn start_listening(&mut self, peer_addr: Multiaddr) -> Result<(), P2PError> {
-        self.swarm
-            .listen_on(peer_addr)
-            .map(|_| ())
-            .map_err(Into::into)
-    }
-
     pub async fn bootstrap(mut self) -> Result<Self, Box<dyn std::error::Error>> {
         if self.bootstrapped {
             return Err(Box::new(P2PError::BootstrapError(
@@ -61,20 +54,19 @@ impl Runtime {
 
         self.bootstrapped = true;
 
-        debug!("Added external addresses: {:?}", self.advertised_addresses);
-        for address in &self.advertised_addresses {
+        debug!("Added external addresses: {:?}", self.public_addresses);
+        for address in &self.public_addresses {
             self.swarm.add_external_address(address.clone());
         }
 
         let dht_address = self
-            .advertised_addresses
+            .public_addresses
             .first()
             .map(Multiaddr::to_vec)
-            .ok_or(P2PError::MissingAdvertisedAddresses)?;
+            .ok_or(P2PError::MissingPublicAddresses)?;
 
         debug!("Starting to listen on {:?}", self.listening_on);
-        let addresses = self.listening_on.clone();
-        for addr in addresses {
+        for addr in &self.listening_on {
             if let Err(error) = self.swarm.listen_on(addr.clone()) {
                 error!("Couldn't start listening on {} because of {error:?}", addr);
 

crates/topos-p2p/src/tests/command/random_peer.rs

@@ -15,7 +15,7 @@ async fn no_random_peer() {
 
     let (client, _, runtime) = crate::network::builder()
         .peer_key(local.keypair.clone())
-        .advertised_addresses(vec![local.addr.clone()])
+        .public_addresses(vec![local.addr.clone()])
         .listen_addresses(vec![local.addr.clone()])
         .build()
         .await
@@ -46,7 +46,7 @@ async fn return_a_peer() {
 
     let (client, _, runtime) = crate::network::builder()
         .peer_key(local.keypair.clone())
-        .advertised_addresses(vec![local.addr.clone()])
+        .public_addresses(vec![local.addr.clone()])
         .listen_addresses(vec![local.addr.clone()])
         .build()
         .await
@@ -75,7 +75,7 @@ async fn return_a_random_peer_among_100() {
 
     let (client, _, runtime) = crate::network::builder()
         .peer_key(local.keypair.clone())
-        .advertised_addresses(vec![local.addr.clone()])
+        .public_addresses(vec![local.addr.clone()])
         .listen_addresses(vec![local.addr.clone()])
         .build()
         .await

crates/topos-p2p/src/tests/dht.rs

@@ -24,7 +24,7 @@ async fn put_value_in_dht() {
     let (_, _, runtime) = crate::network::builder()
         .peer_key(peer_2.keypair.clone())
         .known_peers(&[(peer_1.peer_id(), peer_1.addr.clone())])
-        .advertised_addresses(vec![peer_2.addr.clone()])
+        .public_addresses(vec![peer_2.addr.clone()])
         .listen_addresses(vec![peer_2.addr.clone()])
         .minimum_cluster_size(1)
         .discovery_config(
@@ -44,7 +44,7 @@ async fn put_value_in_dht() {
             Record::new(
                 input_key.clone(),
                 runtime
-                    .advertised_addresses
+                    .public_addresses
                     .first()
                     .map(Multiaddr::to_vec)
                     .unwrap(),

crates/topos-tce/src/config.rs

@@ -30,7 +30,7 @@ pub struct TceConfiguration {
     pub minimum_cluster_size: usize,
     pub version: &'static str,
     pub listen_addresses: Vec<Multiaddr>,
-    pub advertised_addresses: Vec<Multiaddr>,
+    pub public_addresses: Vec<Multiaddr>,
 }
 
 #[derive(Debug)]

crates/topos-tce/src/lib.rs

@@ -139,7 +139,7 @@ pub async fn run(
         .peer_key(key)
         .listen_addresses(config.listen_addresses.clone())
         .minimum_cluster_size(config.minimum_cluster_size)
-        .advertised_addresses(config.advertised_addresses.clone())
+        .public_addresses(config.public_addresses.clone())
         .known_peers(&boot_peers)
         .grpc_context(grpc_context)
         .build()

crates/topos-test-sdk/src/tce/p2p.rs

@@ -50,7 +50,7 @@ pub async fn create_network_worker(
     topos_p2p::network::builder()
         .peer_key(key.clone())
         .known_peers(&known_peers)
-        .advertised_addresses(addr.clone())
+        .public_addresses(addr.clone())
         .listen_addresses(addr)
         .minimum_cluster_size(minimum_cluster_size)
         .grpc_context(grpc_context)

crates/topos/src/components/node/services/process.rs

@@ -99,7 +99,7 @@ pub(crate) fn spawn_tce_process(
             .expect("Unable to generate Multiaddr from `libp2p_api_addr`");
 
         config.p2p.listen_addresses = vec![addr.clone()];
-        config.p2p.advertised_addresses = vec![addr];
+        config.p2p.public_addresses = vec![addr];
     }
 
     let tce_config = TceConfiguration {
@@ -112,7 +112,7 @@ pub(crate) fn spawn_tce_process(
         auth_key: keys.network.map(AuthKey::PrivateKey),
         signing_key: keys.validator.map(AuthKey::PrivateKey),
         listen_addresses: config.p2p.listen_addresses,
-        advertised_addresses: config.p2p.advertised_addresses,
+        public_addresses: config.p2p.public_addresses,
         tce_params,
         api_addr: config.grpc_api_addr,
         graphql_api_addr: config.graphql_api_addr,

crates/topos/src/config/tce.rs

@@ -59,15 +59,15 @@ pub struct P2PConfig {
     #[serde(default = "default_listen_addresses")]
     pub listen_addresses: Vec<Multiaddr>,
     /// List of multiaddresses to advertise to the network
-    #[serde(default = "default_advertised_addresses")]
-    pub advertised_addresses: Vec<Multiaddr>,
+    #[serde(default = "default_public_addresses")]
+    pub public_addresses: Vec<Multiaddr>,
 }
 
 impl Default for P2PConfig {
     fn default() -> Self {
         Self {
             listen_addresses: default_listen_addresses(),
-            advertised_addresses: default_advertised_addresses(),
+            public_addresses: default_public_addresses(),
         }
     }
 }
@@ -99,7 +99,7 @@ fn default_listen_addresses() -> Vec<Multiaddr> {
     )]
 }
 
-fn default_advertised_addresses() -> Vec<Multiaddr> {
+fn default_public_addresses() -> Vec<Multiaddr> {
     vec![format!(
         "/ip4/{}/tcp/{}",
         default_libp2p_api_addr().ip(),
@@ -108,7 +108,7 @@ fn default_advertised_addresses() -> Vec<Multiaddr> {
     .parse()
     .expect(
         r#"
-        Advertised multiaddresses generation failure.
+        Public multiaddresses generation failure.
         This is a critical bug that need to be report on `https://github.com/topos-protocol/topos/issues`
     "#,
     )]

crates/topos/tests/config.rs

@@ -416,6 +416,7 @@ async fn command_node_up_with_old_config(
         .env("TOPOS_POLYGON_EDGE_BIN_PATH", &node_edge_path_env)
         .env("TOPOS_NODE_NAME", node_up_name_env)
         .env("TOPOS_HOME", node_up_home_env)
+        .env("RUST_LOG", "topos=info")
         .arg("up")
         .stdout(Stdio::piped())
         .spawn()?;
@@ -426,6 +427,7 @@ async fn command_node_up_with_old_config(
     let stdout = join.join().unwrap()?.stdout;
     let stdout = String::from_utf8_lossy(&stdout);
 
+    println!("STDOUT: {}", stdout);
     assert!(stdout.contains(r#"Local node is listening on "/ip4/127.0.0.1/tcp/9091/p2p/"#));
 
     // Cleanup