adapt non-default discovery mechanisms

rklaehn · rklaehn · commit 9b0bfd930cd8 · 2025-11-13T10:24:27.000-06:00
diff --git a/iroh-base/src/endpoint_addr.rs b/iroh-base/src/endpoint_addr.rs
@@ -67,7 +67,10 @@ impl EndpointAddr {
     }
 
     /// Creates a new [`EndpointAddr`] from its parts.
-    pub fn from_parts(id: impl Into<EndpointId>, addrs: impl IntoIterator<Item = TransportAddr>) -> Self {
+    pub fn from_parts(
+        id: impl Into<EndpointId>,
+        addrs: impl IntoIterator<Item = TransportAddr>,
+    ) -> Self {
         Self {
             id: id.into(),
             addrs: addrs.into_iter().collect(),
diff --git a/iroh-base/src/lib.rs b/iroh-base/src/lib.rs
@@ -13,6 +13,6 @@ mod relay_url;
 #[cfg(feature = "key")]
 pub use self::endpoint_addr::{EndpointAddr, TransportAddr};
 #[cfg(feature = "key")]
-pub use self::key::{EndpointId, PublicKey, KeyParsingError, SecretKey, Signature, SignatureError};
+pub use self::key::{EndpointId, KeyParsingError, PublicKey, SecretKey, Signature, SignatureError};
 #[cfg(feature = "relay")]
 pub use self::relay_url::{RelayUrl, RelayUrlParseError};
diff --git a/iroh-dns-server/examples/publish.rs b/iroh-dns-server/examples/publish.rs
@@ -8,7 +8,7 @@ use iroh::{
         dns::{N0_DNS_ENDPOINT_ORIGIN_PROD, N0_DNS_ENDPOINT_ORIGIN_STAGING},
         pkarr::{N0_DNS_PKARR_RELAY_PROD, N0_DNS_PKARR_RELAY_STAGING, PkarrRelayClient},
     },
-    endpoint_info::{PublicKeyExt, EndpointInfo, IROH_TXT_NAME},
+    endpoint_info::{EndpointInfo, IROH_TXT_NAME, PublicKeyExt},
 };
 use n0_error::{Result, StackResultExt};
 use url::Url;
diff --git a/iroh-relay/src/endpoint_info.rs b/iroh-relay/src/endpoint_info.rs
@@ -40,7 +40,9 @@ use std::{
     str::{FromStr, Utf8Error},
 };
 
-use iroh_base::{EndpointAddr, EndpointId, KeyParsingError, PublicKey, RelayUrl, SecretKey, TransportAddr};
+use iroh_base::{
+    EndpointAddr, EndpointId, KeyParsingError, PublicKey, RelayUrl, SecretKey, TransportAddr,
+};
 use n0_error::{e, ensure, stack_error};
 use url::Url;
 
@@ -321,7 +323,10 @@ impl From<&TxtAttrs<IrohAttr>> for EndpointInfo {
         data.set_user_data(user_data);
         data.add_addrs(relay_urls.chain(ip_addrs));
 
-        Self { endpoint_id: endpoint_id.into(), data }
+        Self {
+            endpoint_id: endpoint_id.into(),
+            data,
+        }
     }
 }
 
@@ -338,7 +343,7 @@ impl From<EndpointAddr> for EndpointInfo {
         info
     }
 }
- 
+
 impl EndpointInfo {
     /// Creates a new [`EndpointInfo`] with an empty [`EndpointData`].
     pub fn new(endpoint_id: impl Into<EndpointId>) -> Self {
@@ -347,7 +352,10 @@ impl EndpointInfo {
 
     /// Creates a new [`EndpointInfo`] from its parts.
     pub fn from_parts(endpoint_id: impl Into<EndpointId>, data: EndpointData) -> Self {
-        Self { endpoint_id: endpoint_id.into(), data }
+        Self {
+            endpoint_id: endpoint_id.into(),
+            data,
+        }
     }
 
     /// Sets the relay URL and returns the updated endpoint info.
@@ -674,7 +682,7 @@ mod tests {
     use iroh_base::{PublicKey, SecretKey, TransportAddr};
     use n0_error::{Result, StdResultExt};
 
-    use super::{EndpointData, PublicKeyExt, EndpointInfo};
+    use super::{EndpointData, EndpointInfo, PublicKeyExt};
     use crate::dns::TxtRecordData;
 
     #[test]
diff --git a/iroh-relay/src/protos/relay.rs b/iroh-relay/src/protos/relay.rs
@@ -10,7 +10,7 @@
 use std::num::NonZeroU16;
 
 use bytes::{Buf, BufMut, Bytes, BytesMut};
-use iroh_base::{PublicKey, KeyParsingError};
+use iroh_base::{KeyParsingError, PublicKey};
 use n0_error::{e, ensure, stack_error};
 use n0_future::time::Duration;
 
diff --git a/iroh-relay/src/server/client.rs b/iroh-relay/src/server/client.rs
@@ -161,10 +161,7 @@ impl Client {
         self.disco_send_queue.try_send(Packet { src, data })
     }
 
-    pub(super) fn try_send_peer_gone(
-        &self,
-        key: PublicKey,
-    ) -> Result<(), TrySendError<PublicKey>> {
+    pub(super) fn try_send_peer_gone(&self, key: PublicKey) -> Result<(), TrySendError<PublicKey>> {
         self.peer_gone.try_send(key)
     }
 }
diff --git a/iroh/examples/locally-discovered-nodes.rs b/iroh/examples/locally-discovered-nodes.rs
@@ -6,7 +6,7 @@
 use std::time::Duration;
 
 use iroh::{
-    Endpoint, PublicKey,
+    Endpoint, EndpointId,
     discovery::mdns::{DiscoveryEvent, MdnsDiscovery},
     endpoint_info::UserData,
 };
@@ -32,7 +32,7 @@ async fn main() -> Result<()> {
     let ud = user_data.clone();
     let discovery_stream_task = tokio::spawn(async move {
         let mut discovery_stream = mdns.subscribe().await;
-        let mut discovered_endpoints: Vec<PublicKey> = vec![];
+        let mut discovered_endpoints: Vec<EndpointId> = vec![];
         while let Some(event) = discovery_stream.next().await {
             match event {
                 DiscoveryEvent::Discovered { endpoint_info, .. } => {
diff --git a/iroh/examples/transfer.rs b/iroh/examples/transfer.rs
@@ -9,10 +9,14 @@ use clap::{Parser, Subcommand};
 use data_encoding::HEXLOWER;
 use indicatif::HumanBytes;
 use iroh::{
-    Endpoint, EndpointAddr, EndpointId, PublicKey, RelayMap, RelayMode, RelayUrl, SecretKey, TransportAddr, discovery::{
+    Endpoint, EndpointAddr, EndpointId, PublicKey, RelayMap, RelayMode, RelayUrl, SecretKey,
+    TransportAddr,
+    discovery::{
         dns::DnsDiscovery,
         pkarr::{N0_DNS_PKARR_RELAY_PROD, N0_DNS_PKARR_RELAY_STAGING, PkarrPublisher},
-    }, dns::{DnsResolver, N0_DNS_ENDPOINT_ORIGIN_PROD, N0_DNS_ENDPOINT_ORIGIN_STAGING}, endpoint::ConnectionError
+    },
+    dns::{DnsResolver, N0_DNS_ENDPOINT_ORIGIN_PROD, N0_DNS_ENDPOINT_ORIGIN_STAGING},
+    endpoint::ConnectionError,
 };
 use n0_error::{Result, StackResultExt, StdResultExt};
 use n0_future::task::AbortOnDropHandle;
diff --git a/iroh/src/discovery.rs b/iroh/src/discovery.rs
@@ -1059,10 +1059,7 @@ mod test_dns_pkarr {
             .await?;
         println!("resolved {resolved:?}");
 
-        let expected_addr = EndpointAddr::from_parts(
-            endpoint_id,
-            relay_url,
-        );
+        let expected_addr = EndpointAddr::from_parts(endpoint_id, relay_url);
 
         assert_eq!(resolved.to_endpoint_addr(), expected_addr);
         assert_eq!(resolved.user_data(), Some(&user_data));
diff --git a/iroh/src/discovery/mdns.rs b/iroh/src/discovery/mdns.rs
@@ -98,10 +98,10 @@ pub struct MdnsDiscovery {
 enum Message {
     Discovery(String, Peer),
     Resolve(
-        EndpointId,
+        PublicKey,
         mpsc::Sender<Result<DiscoveryItem, DiscoveryError>>,
     ),
-    Timeout(EndpointId, usize),
+    Timeout(PublicKey, usize),
     Subscribe(mpsc::Sender<DiscoveryEvent>),
 }
 
@@ -190,7 +190,7 @@ impl MdnsDiscoveryBuilder {
     /// # Panics
     /// This relies on [`tokio::runtime::Handle::current`] and will panic if called outside of the context of a tokio runtime.
     pub fn build(self, endpoint_id: EndpointId) -> Result<MdnsDiscovery, IntoDiscoveryError> {
-        MdnsDiscovery::new(endpoint_id, self.advertise, self.service_name)
+        MdnsDiscovery::new(endpoint_id.expect_ed(), self.advertise, self.service_name)
     }
 }
 
@@ -241,7 +241,7 @@ impl MdnsDiscovery {
     /// # Panics
     /// This relies on [`tokio::runtime::Handle::current`] and will panic if called outside of the context of a tokio runtime.
     fn new(
-        endpoint_id: EndpointId,
+        endpoint_id: PublicKey,
         advertise: bool,
         service_name: String,
     ) -> Result<Self, IntoDiscoveryError> {
@@ -332,7 +332,7 @@ impl MdnsDiscovery {
                             );
                             endpoint_addrs.remove(&discovered_endpoint_id);
                             subscribers.send(DiscoveryEvent::Expired {
-                                endpoint_id: discovered_endpoint_id,
+                                endpoint_id: discovered_endpoint_id.into(),
                             });
                             continue;
                         }
@@ -352,7 +352,8 @@ impl MdnsDiscovery {
                         );
 
                         let mut resolved = false;
-                        let item = peer_to_discovery_item(&peer_info, &discovered_endpoint_id);
+                        let item =
+                            peer_to_discovery_item(&peer_info, &discovered_endpoint_id.into());
                         if let Some(senders) = senders.get(&discovered_endpoint_id) {
                             trace!(?item, senders = senders.len(), "sending DiscoveryItem");
                             resolved = true;
@@ -372,21 +373,21 @@ impl MdnsDiscovery {
                             });
                         }
                     }
-                    Message::Resolve(endpoint_id, sender) => {
+                    Message::Resolve(public_key, sender) => {
                         let id = last_id + 1;
                         last_id = id;
-                        trace!(?endpoint_id, "MdnsDiscovery Message::SendAddrs");
-                        if let Some(peer_info) = endpoint_addrs.get(&endpoint_id) {
-                            let item = peer_to_discovery_item(peer_info, &endpoint_id);
+                        trace!(?public_key, "MdnsDiscovery Message::SendAddrs");
+                        if let Some(peer_info) = endpoint_addrs.get(&public_key) {
+                            let item = peer_to_discovery_item(peer_info, &public_key);
                             debug!(?item, "sending DiscoveryItem");
                             sender.send(Ok(item)).await.ok();
                         }
-                        if let Some(senders_for_endpoint_id) = senders.get_mut(&endpoint_id) {
+                        if let Some(senders_for_endpoint_id) = senders.get_mut(&public_key) {
                             senders_for_endpoint_id.insert(id, sender);
                         } else {
                             let mut senders_for_endpoint_id = HashMap::new();
                             senders_for_endpoint_id.insert(id, sender);
-                            senders.insert(endpoint_id, senders_for_endpoint_id);
+                            senders.insert(public_key, senders_for_endpoint_id);
                         }
                         let timeout_sender = task_sender.clone();
                         timeouts.spawn(async move {
@@ -398,12 +399,12 @@ impl MdnsDiscovery {
                                 .ok();
                         });
                     }
-                    Message::Timeout(endpoint_id, id) => {
-                        trace!(?endpoint_id, "MdnsDiscovery Message::Timeout");
-                        if let Some(senders_for_endpoint_id) = senders.get_mut(&endpoint_id) {
+                    Message::Timeout(public_key, id) => {
+                        trace!(?public_key, "MdnsDiscovery Message::Timeout");
+                        if let Some(senders_for_endpoint_id) = senders.get_mut(&public_key) {
                             senders_for_endpoint_id.remove(&id);
                             if senders_for_endpoint_id.is_empty() {
-                                senders.remove(&endpoint_id);
+                                senders.remove(&public_key);
                             }
                         }
                     }
@@ -488,7 +489,7 @@ impl MdnsDiscovery {
     }
 }
 
-fn peer_to_discovery_item(peer: &Peer, endpoint_id: &EndpointId) -> DiscoveryItem {
+fn peer_to_discovery_item(peer: &Peer, public_key: &PublicKey) -> DiscoveryItem {
     let ip_addrs: BTreeSet<SocketAddr> = peer
         .addrs()
         .iter()
@@ -507,7 +508,7 @@ fn peer_to_discovery_item(peer: &Peer, endpoint_id: &EndpointId) -> DiscoveryIte
     } else {
         None
     };
-    let endpoint_info = EndpointInfo::new(*endpoint_id)
+    let endpoint_info = EndpointInfo::new(*public_key)
         .with_ip_addrs(ip_addrs)
         .with_user_data(user_data);
     DiscoveryItem::new(endpoint_info, NAME, None)
@@ -520,11 +521,13 @@ impl Discovery for MdnsDiscovery {
     ) -> Option<BoxStream<Result<DiscoveryItem, DiscoveryError>>> {
         use futures_util::FutureExt;
 
+        let public_key = endpoint_id.as_ed()?;
+
         let (send, recv) = mpsc::channel(20);
         let discovery_sender = self.sender.clone();
         let stream = async move {
             discovery_sender
-                .send(Message::Resolve(endpoint_id, send))
+                .send(Message::Resolve(public_key, send))
                 .await
                 .ok();
             tokio_stream::wrappers::ReceiverStream::new(recv)
@@ -762,19 +765,19 @@ mod tests {
 
             // Create a discovery service using the default
             // service name
-            let id_a = SecretKey::generate(&mut rng).public();
+            let id_a = SecretKey::generate(&mut rng).public().into();
             let discovery_a = MdnsDiscovery::builder().build(id_a)?;
 
             // Create a discovery service using a custom
             // service name
-            let id_b = SecretKey::generate(&mut rng).public();
+            let id_b = SecretKey::generate(&mut rng).public().into();
             let discovery_b = MdnsDiscovery::builder()
                 .service_name("different.name")
                 .build(id_b)?;
 
             // Create a discovery service using the same
             // custom service name
-            let id_c = SecretKey::generate(&mut rng).public();
+            let id_c = SecretKey::generate(&mut rng).public().into();
             let discovery_c = MdnsDiscovery::builder()
                 .service_name("different.name")
                 .build(id_c)?;
@@ -818,8 +821,8 @@ mod tests {
         fn make_discoverer<R: CryptoRng + ?Sized>(
             rng: &mut R,
             advertise: bool,
-        ) -> Result<(PublicKey, MdnsDiscovery)> {
-            let endpoint_id = SecretKey::generate(rng).public();
+        ) -> Result<(EndpointId, MdnsDiscovery)> {
+            let endpoint_id = SecretKey::generate(rng).public().into();
             Ok((
                 endpoint_id,
                 MdnsDiscovery::builder()
diff --git a/iroh/src/discovery/pkarr/dht.rs b/iroh/src/discovery/pkarr/dht.rs
@@ -315,8 +315,9 @@ impl Discovery for DhtDiscovery {
         &self,
         endpoint_id: EndpointId,
     ) -> Option<BoxStream<Result<DiscoveryItem, DiscoveryError>>> {
+        let public_key = endpoint_id.as_ed()?;
         let pkarr_public_key =
-            pkarr::PublicKey::try_from(endpoint_id.as_bytes()).expect("valid public key");
+            pkarr::PublicKey::try_from(public_key.as_bytes()).expect("valid public key");
         tracing::info!("resolving {} as {}", endpoint_id, pkarr_public_key.to_z32());
         let discovery = self.0.clone();
         let stream = n0_future::stream::once_future(async move {
@@ -364,7 +365,7 @@ mod tests {
                 tokio::time::sleep(Duration::from_millis(200)).await;
                 let mut found_relay_urls = BTreeSet::new();
                 let items = discovery
-                    .resolve(secret.public())
+                    .resolve(secret.public().into())
                     .unwrap()
                     .collect::<Vec<_>>()
                     .await;
diff --git a/iroh/src/discovery/static_provider.rs b/iroh/src/discovery/static_provider.rs
@@ -55,7 +55,7 @@ use super::{Discovery, DiscoveryError, DiscoveryItem, EndpointData, EndpointInfo
 /// // You can pass either `EndpointInfo` or `EndpointAddr` to `add_endpoint_info`.
 /// discovery.add_endpoint_info(EndpointAddr::from_parts(
 ///     id,
-///     [TransportAddr::Relay("https://example.com".parse()?)]
+///     [TransportAddr::Relay("https://example.com".parse()?)],
 /// ));
 ///
 /// # Ok(())
@@ -248,7 +248,7 @@ mod tests {
         let key = SecretKey::from_bytes(&[0u8; 32]);
         let addr = EndpointAddr::from_parts(
             key.public(),
-            [TransportAddr::Relay("https://example.com".parse()?)]
+            [TransportAddr::Relay("https://example.com".parse()?)],
         );
         let user_data = Some("foobar".parse().unwrap());
         let endpoint_info = EndpointInfo::from(addr.clone()).with_user_data(user_data.clone());
@@ -278,7 +278,7 @@ mod tests {
         let key = SecretKey::from_bytes(&[0u8; 32]);
         let addr = EndpointAddr::from_parts(
             key.public(),
-            [TransportAddr::Relay("https://example.com".parse()?)]
+            [TransportAddr::Relay("https://example.com".parse()?)],
         );
         discovery.add_endpoint_info(addr);
         let mut stream = discovery.resolve(key.public().into()).unwrap();
diff --git a/iroh/src/endpoint.rs b/iroh/src/endpoint.rs
diff --git a/iroh/src/endpoint/connection.rs b/iroh/src/endpoint/connection.rs
diff --git a/iroh/src/lib.rs b/iroh/src/lib.rs
diff --git a/iroh/src/magicsock.rs b/iroh/src/magicsock.rs
diff --git a/iroh/src/test_utils.rs b/iroh/src/test_utils.rs

Original file line number	Diff line number	Diff line change
`@@ -161,10 +161,7 @@ impl Client {`
`161`	`161`	`self.disco_send_queue.try_send(Packet { src, data })`
`162`	`162`	`}`
`163`	`163`
`164`		`- pub(super) fn try_send_peer_gone(`
`165`		`- &self,`
`166`		`- key: PublicKey,`
`167`		`- ) -> Result<(), TrySendError<PublicKey>> {`
	`164`	`+ pub(super) fn try_send_peer_gone(&self, key: PublicKey) -> Result<(), TrySendError<PublicKey>> {`
`168`	`165`	`self.peer_gone.try_send(key)`
`169`	`166`	`}`
`170`	`167`	`}`