fix: remove duplicate receive loops by moving networking setup from new() to start()

P2PNode::new() and start() both called start_network_listeners() and
start_message_receiving_system(), spawning duplicate accept and receive
loops competing on the same QUIC endpoint. This caused messages to be
randomly split between loops, leading to flaky delivery.

Now new() only constructs the struct; start() is the single place where
background loops are spawned. All callers updated to call start() after
new().

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mickvandijke

examples/chat.rs

@@ -64,6 +64,7 @@ async fn main() -> Result<()> {
 
     // Create and start the node
     let node = P2PNode::new(config).await?;
+    node.start().await?;
 
     // Handle bootstrap peers
     let mut bootstrap_addrs: Vec<Multiaddr> = Vec::new();

examples/test_network.rs

@@ -71,6 +71,7 @@ impl TestNode {
                 .await
                 .context("Failed to create P2P node")?,
         );
+        node.start().await.context("Failed to start P2P node")?;
 
         // Get actual listen addresses after node creation
         let actual_addrs = node.listen_addrs().await;

src/messaging/service.rs

@@ -293,6 +293,7 @@ impl MessagingService {
             }
 
             let node = crate::network::P2PNode::new(node_config).await?;
+            node.start().await?;
             Arc::new(node)
         };
         let transport = Arc::new(MessageTransport::new(network, dht_client.clone()).await?);

src/network.rs

@@ -1037,17 +1037,7 @@ impl P2PNode {
             entangled_id: None,
             binary_hash,
         };
-        info!("Created P2P node with peer ID: {}", node.peer_id);
-
-        // Start the network listeners to populate listen addresses
-        node.start_network_listeners().await?;
-
-        // Update the connection monitor with actual peers reference
-        node.start_connection_monitor().await;
-
-        // Start message receiving system so messages work immediately after node creation
-        // This is critical for basic P2P messaging to work
-        node.start_message_receiving_system().await?;
+        info!("Created P2P node with peer ID: {} (call start() to begin networking)", node.peer_id);
 
         Ok(node)
     }
@@ -1159,12 +1149,13 @@ impl P2PNode {
         // Start listening on configured addresses using transport layer
         self.start_network_listeners().await?;
 
+        // Update the connection monitor with actual peers reference
+        self.start_connection_monitor().await;
+
         // Log current listen addresses
         let listen_addrs = self.listen_addrs.read().await;
         info!("P2P node started on addresses: {:?}", *listen_addrs);
 
-        // MCP removed
-
         // Start message receiving system
         self.start_message_receiving_system().await?;
 

tests/connection_lifecycle_integration_test.rs

@@ -66,7 +66,9 @@ async fn test_connection_lifecycle_with_keepalive() {
     };
 
     let node1 = P2PNode::new(config1).await.expect("Failed to create node1");
+    node1.start().await.expect("Failed to start node1");
     let node2 = P2PNode::new(config2).await.expect("Failed to create node2");
+    node2.start().await.expect("Failed to start node2");
 
     // Get their addresses
     let addrs1 = node1.listen_addrs().await;
@@ -182,7 +184,9 @@ async fn test_send_message_validates_connection_state() {
     };
 
     let node1 = P2PNode::new(config1).await.expect("Failed to create node1");
+    node1.start().await.expect("Failed to start node1");
     let node2 = P2PNode::new(config2).await.expect("Failed to create node2");
+    node2.start().await.expect("Failed to start node2");
 
     // Get addresses and connect
     let addrs2 = node2.listen_addrs().await;
@@ -265,7 +269,9 @@ async fn test_multiple_message_exchanges() {
     };
 
     let node1 = P2PNode::new(config1).await.expect("Failed to create node1");
+    node1.start().await.expect("Failed to start node1");
     let node2 = P2PNode::new(config2).await.expect("Failed to create node2");
+    node2.start().await.expect("Failed to start node2");
 
     // Connect nodes
     let addrs2 = node2.listen_addrs().await;

tests/connection_lifecycle_proof_test.rs

@@ -37,6 +37,7 @@ async fn test_connection_lifecycle_infrastructure_exists() {
     };
 
     let node = P2PNode::new(config).await.expect("Failed to create node");
+    node.start().await.expect("Failed to start node");
 
     info!("Node created successfully");
 
@@ -112,6 +113,7 @@ async fn test_keepalive_task_initialized() {
     };
 
     let _node = P2PNode::new(config).await.expect("Failed to create node");
+    _node.start().await.expect("Failed to start node");
 
     // The keepalive task is spawned in P2PNode::new() and runs in the background
     // It sends keepalive messages every 15 seconds to prevent the 30-second ant-quic timeout

tests/end_to_end_scenarios_test.rs

@@ -46,6 +46,7 @@ impl TestUser {
 
         let peer_id = format!("test_user_{}", username);
         let node = P2PNode::new(config).await?;
+        node.start().await?;
 
         Ok(Self {
             node: Arc::new(node),
@@ -55,7 +56,7 @@ impl TestUser {
     }
 
     async fn start(&self) -> Result<()> {
-        // TODO: Implement when node.start() API is available
+        // Node is already started after P2PNode::new() + start() in TestUser::new()
         sleep(Duration::from_millis(100)).await;
         Ok(())
     }