telephony: refresh route hops after path resolution

defidude · defidude · commit 926cb62d8c99 · 2026-05-14T01:11:28.000-06:00
diff --git a/crates/lxst-telephony/src/lib.rs b/crates/lxst-telephony/src/lib.rs
@@ -1363,8 +1363,13 @@ impl TelephonyService {
                     discovery_timeout,
                 )
                 .await?;
-                await_path_on_transport(transport_tx, peer.destination_hash, discovery_timeout)
-                    .await?;
+                await_path_on_transport(
+                    transport_tx.clone(),
+                    peer.destination_hash,
+                    discovery_timeout,
+                )
+                .await?;
+                let peer = refresh_peer_hops_from_transport(transport_tx, peer).await?;
                 Ok(peer)
             }
             .await;
@@ -2212,6 +2217,7 @@ impl TelephonyRnsEndpoint {
             discovery_timeout,
         )
         .await?;
+        let peer = refresh_peer_hops_from_transport(self.transport_tx.clone(), peer).await?;
         self.begin_outgoing_link_with_remote_pubkey(
             core,
             remote_identity,
@@ -2896,6 +2902,40 @@ async fn await_path_on_transport(
     }
 }
 
+async fn refresh_peer_hops_from_transport(
+    transport_tx: mpsc::Sender<TransportMessage>,
+    mut peer: RemoteTelephonyPeer,
+) -> Result<RemoteTelephonyPeer, Error> {
+    if let Some(hops) = path_hops_on_transport(transport_tx, peer.destination_hash).await? {
+        peer.hops = hops;
+    }
+    Ok(peer)
+}
+
+async fn path_hops_on_transport(
+    transport_tx: mpsc::Sender<TransportMessage>,
+    destination_hash: [u8; 16],
+) -> Result<Option<u8>, Error> {
+    let (response_tx, response_rx) = tokio::sync::oneshot::channel();
+    send_transport_async(
+        transport_tx,
+        TransportMessage::Rpc {
+            query: TransportQuery::GetPathTable,
+            response_tx,
+        },
+    )
+    .await?;
+
+    match response_rx.await.map_err(|_| Error::TransportQueryClosed)? {
+        TransportQueryResponse::PathTable(entries) => Ok(entries
+            .into_iter()
+            .find(|entry| entry.hash == destination_hash)
+            .map(|entry| entry.hops)),
+        TransportQueryResponse::Error(_) => Err(Error::UnexpectedTransportQueryResponse),
+        _ => Err(Error::UnexpectedTransportQueryResponse),
+    }
+}
+
 async fn send_transport_async(
     transport_tx: mpsc::Sender<TransportMessage>,
     message: TransportMessage,
diff --git a/crates/lxst-telephony/src/tests.rs b/crates/lxst-telephony/src/tests.rs
@@ -6,7 +6,7 @@ use rns_crypto::ed25519::Ed25519PrivateKey;
 use rns_identity::announce::AnnounceData;
 use rns_link::link::LinkState;
 use rns_transport::messages::{
-    AnnounceRpcEntry, TransportMessage, TransportQuery, TransportQueryResponse,
+    AnnounceRpcEntry, PathTableRpcEntry, TransportMessage, TransportQuery, TransportQueryResponse,
 };
 
 fn link(byte: u8) -> LinkId {
@@ -52,6 +52,17 @@ fn announce_entry(
     }
 }
 
+fn path_entry(destination_hash: [u8; 16], hops: u8) -> PathTableRpcEntry {
+    PathTableRpcEntry {
+        hash: destination_hash,
+        timestamp: 1235.0,
+        via: None,
+        hops,
+        expires: 3600.0,
+        interface: "test".to_string(),
+    }
+}
+
 fn packet(signals: impl IntoIterator<Item = Signal>) -> Vec<u8> {
     LxstPacket::signalling(signals).encode().unwrap()
 }
@@ -1284,6 +1295,18 @@ async fn begin_outgoing_link_discovers_announce_and_sends_link_request() {
         assert_eq!(dest, destination_hash);
         reply.send(true).unwrap();
 
+        let rpc = transport_rx.recv().await.unwrap();
+        let TransportMessage::Rpc { query, response_tx } = rpc else {
+            panic!("expected path table Rpc, got {rpc:?}");
+        };
+        assert!(matches!(query, TransportQuery::GetPathTable));
+        response_tx
+            .send(TransportQueryResponse::PathTable(vec![path_entry(
+                destination_hash,
+                2,
+            )]))
+            .unwrap();
+
         let request_path = transport_rx.recv().await.unwrap();
         let TransportMessage::RequestPath {
             destination_hash: requested_hash,
@@ -1766,6 +1789,18 @@ async fn telephony_service_call_control_discovers_peer_and_emits_started() {
     assert_eq!(dest, destination_hash);
     reply.send(true).unwrap();
 
+    let rpc = transport_rx.recv().await.unwrap();
+    let TransportMessage::Rpc { query, response_tx } = rpc else {
+        panic!("expected path table Rpc, got {rpc:?}");
+    };
+    assert!(matches!(query, TransportQuery::GetPathTable));
+    response_tx
+        .send(TransportQueryResponse::PathTable(vec![path_entry(
+            destination_hash,
+            1,
+        )]))
+        .unwrap();
+
     let request_path = transport_rx.recv().await.unwrap();
     let TransportMessage::RequestPath {
         destination_hash: requested_hash,
