feat(connect): propagate courtesy metadata

Author: sanity

crates/core/src/message.rs

@@ -367,6 +367,7 @@ pub(crate) enum NodeEvent {
     /// Register expectation for an inbound connection from the given peer.
     ExpectPeerConnection {
         peer: PeerId,
+        courtesy: bool,
     },
 }
 
@@ -444,8 +445,11 @@ impl Display for NodeEvent {
                     "Local subscribe complete (tx: {tx}, key: {key}, subscribed: {subscribed})"
                 )
             }
-            NodeEvent::ExpectPeerConnection { peer } => {
-                write!(f, "ExpectPeerConnection (from {peer})")
+            NodeEvent::ExpectPeerConnection { peer, courtesy } => {
+                write!(
+                    f,
+                    "ExpectPeerConnection (from {peer}, courtesy: {courtesy})"
+                )
             }
         }
     }

crates/core/src/node/network_bridge/p2p_protoc.rs

@@ -629,14 +629,14 @@ impl P2pConnManager {
                                 )
                                 .await?;
                             }
-                            NodeEvent::ExpectPeerConnection { peer } => {
-                                tracing::debug!(%peer, "ExpectPeerConnection event received; registering inbound expectation via handshake driver");
+                            NodeEvent::ExpectPeerConnection { peer, courtesy } => {
+                                tracing::debug!(%peer, courtesy, "ExpectPeerConnection event received; registering inbound expectation via handshake driver");
                                 state.outbound_handler.expect_incoming(peer.addr);
                                 if let Err(error) = handshake_cmd_sender
                                     .send(HandshakeCommand::ExpectInbound {
                                         peer: peer.clone(),
                                         transaction: None,
-                                        courtesy: false,
+                                        courtesy,
                                     })
                                     .await
                                 {
@@ -1370,8 +1370,15 @@ impl P2pConnManager {
                     "Inbound connection established"
                 );
 
-                self.handle_successful_connection(peer_id, connection, state, select_stream, None)
-                    .await?;
+                self.handle_successful_connection(
+                    peer_id,
+                    connection,
+                    state,
+                    select_stream,
+                    None,
+                    courtesy,
+                )
+                .await?;
             }
             HandshakeEvent::OutboundEstablished {
                 transaction,
@@ -1385,8 +1392,15 @@ impl P2pConnManager {
                     transaction = %transaction,
                     "Outbound connection established"
                 );
-                self.handle_successful_connection(peer, connection, state, select_stream, None)
-                    .await?;
+                self.handle_successful_connection(
+                    peer,
+                    connection,
+                    state,
+                    select_stream,
+                    None,
+                    courtesy,
+                )
+                .await?;
             }
             HandshakeEvent::OutboundFailed {
                 transaction,
@@ -1501,6 +1515,7 @@ impl P2pConnManager {
         state: &mut EventListenerState,
         select_stream: &mut priority_select::ProductionPrioritySelectStream,
         remaining_checks: Option<usize>,
+        courtesy: bool,
     ) -> anyhow::Result<()> {
         let pending_txs = state
             .awaiting_connection_txs

crates/core/src/node/testing_impl.rs

@@ -935,8 +935,8 @@ where
                 NodeEvent::QueryNodeDiagnostics { .. } => {
                     unimplemented!()
                 }
-                NodeEvent::ExpectPeerConnection { peer } => {
-                    tracing::debug!(%peer, "ExpectPeerConnection ignored in testing impl");
+                NodeEvent::ExpectPeerConnection { peer, courtesy } => {
+                    tracing::debug!(%peer, courtesy, "ExpectPeerConnection ignored in testing impl");
                     continue;
                 }
             },

crates/core/src/operations/connect.rs

@@ -178,10 +178,16 @@ pub(crate) trait RelayContext {
 }
 
 /// Result of processing a request at a relay.
+#[derive(Debug, Clone)]
+pub(crate) struct ExpectedConnection {
+    pub peer: PeerKeyLocation,
+    pub courtesy: bool,
+}
+
 #[derive(Debug, Default)]
 pub(crate) struct RelayActions {
     pub accept_response: Option<ConnectResponse>,
-    pub expect_connection_from: Option<PeerKeyLocation>,
+    pub expect_connection_from: Option<ExpectedConnection>,
     pub forward: Option<(PeerKeyLocation, ConnectRequest)>,
     pub observed_address: Option<(PeerKeyLocation, SocketAddr)>,
 }
@@ -218,7 +224,10 @@ impl RelayState {
                 acceptor: acceptor.clone(),
                 courtesy,
             });
-            actions.expect_connection_from = Some(self.request.origin.clone());
+            actions.expect_connection_from = Some(ExpectedConnection {
+                peer: self.request.origin.clone(),
+                courtesy,
+            });
         }
 
         if self.forwarded_to.is_none() && self.request.ttl > 0 {
@@ -589,10 +598,11 @@ impl Operation for ConnectOp {
                             .await?;
                     }
 
-                    if let Some(peer) = actions.expect_connection_from {
+                    if let Some(expected) = actions.expect_connection_from {
                         op_manager
                             .notify_node_event(NodeEvent::ExpectPeerConnection {
-                                peer: peer.peer.clone(),
+                                peer: expected.peer.peer.clone(),
+                                courtesy: expected.courtesy,
                             })
                             .await?;
                     }
@@ -651,6 +661,7 @@ impl Operation for ConnectOp {
                                     .notify_node_event(
                                         crate::message::NodeEvent::ExpectPeerConnection {
                                             peer: new_acceptor.peer.peer.clone(),
+                                            courtesy: new_acceptor.courtesy,
                                         },
                                     )
                                     .await?;
@@ -1040,7 +1051,10 @@ mod tests {
         let response = actions.accept_response.expect("expected acceptance");
         assert_eq!(response.acceptor.peer, self_loc.peer);
         assert!(response.courtesy);
-        assert_eq!(actions.expect_connection_from.unwrap().peer, joiner.peer);
+        assert_eq!(
+            actions.expect_connection_from.unwrap().peer.peer,
+            joiner.peer
+        );
         assert!(actions.forward.is_none());
     }