Remove Other from EndpointId and make it non_exhaustive

rklaehn · rklaehn · commit cadee48400c6 · 2025-11-13T08:54:39.000-06:00
diff --git a/iroh-base/src/key.rs b/iroh-base/src/key.rs
@@ -25,18 +25,16 @@ pub struct PublicKey(CompressedEdwardsY);
 
 /// The identifier for an endpoint in the (iroh) network.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[non_exhaustive]
 pub enum EndpointId {
     /// An Ed25519 public key.
     Ed25519(PublicKey),
-    /// Other types of endpoint identifiers.
-    Other([u8; 8]),
 }
 
 impl PartialEq<PublicKey> for EndpointId {
     fn eq(&self, other: &PublicKey) -> bool {
         match self {
             EndpointId::Ed25519(key) => key == other,
-            EndpointId::Other(_) => false,
         }
     }
 }
@@ -45,7 +43,6 @@ impl Display for EndpointId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             EndpointId::Ed25519(key) => write!(f, "Ed25519({})", key),
-            EndpointId::Other(bytes) => write!(f, "Other({})", data_encoding::HEXLOWER.encode(bytes)),
         }
     }
 }
@@ -55,7 +52,6 @@ impl EndpointId {
     pub fn as_ed(self) -> Option<PublicKey> {
         match self {
             EndpointId::Ed25519(key) => Some(key),
-            EndpointId::Other(_) => None,
         }
     }
 
@@ -68,7 +64,6 @@ impl EndpointId {
     pub fn fmt_short(&self) -> String {
         match self {
             EndpointId::Ed25519(key) => key.fmt_short().to_string(),
-            EndpointId::Other(_) => "Other".to_string(),
         }
     }
 }
diff --git a/iroh/examples/transfer.rs b/iroh/examples/transfer.rs
@@ -9,13 +9,10 @@ use clap::{Parser, Subcommand};
 use data_encoding::HEXLOWER;
 use indicatif::HumanBytes;
 use iroh::{
-    Endpoint, EndpointAddr, 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;
@@ -404,7 +401,7 @@ async fn fetch(endpoint: Endpoint, remote_addr: EndpointAddr) -> Result<()> {
     let conn = endpoint.connect(remote_addr, TRANSFER_ALPN).await?;
     println!("Connected to {}", remote_id);
     // Spawn a background task that prints connection type changes. Will be aborted on drop.
-    let _guard = watch_conn_type(&endpoint, remote_id.expect_ed());
+    let _guard = watch_conn_type(&endpoint, remote_id);
 
     // Use the Quinn API to send and recv content.
     let (mut send, mut recv) = conn.open_bi().await.anyerr()?;
@@ -521,7 +518,7 @@ fn parse_byte_size(s: &str) -> std::result::Result<u64, parse_size::Error> {
     cfg.parse_size(s)
 }
 
-fn watch_conn_type(endpoint: &Endpoint, endpoint_id: PublicKey) -> AbortOnDropHandle<()> {
+fn watch_conn_type(endpoint: &Endpoint, endpoint_id: EndpointId) -> AbortOnDropHandle<()> {
     let mut stream = endpoint.conn_type(endpoint_id).unwrap().stream();
     let task = tokio::task::spawn(async move {
         while let Some(conn_type) = stream.next().await {
diff --git a/iroh/src/endpoint.rs b/iroh/src/endpoint.rs
@@ -16,7 +16,7 @@ use std::{
     sync::Arc,
 };
 
-use iroh_base::{EndpointAddr, EndpointId, PublicKey, RelayUrl, SecretKey, TransportAddr};
+use iroh_base::{EndpointAddr, EndpointId, RelayUrl, SecretKey, TransportAddr};
 use iroh_relay::{RelayConfig, RelayMap};
 use n0_error::{e, ensure, stack_error};
 use n0_future::time::Duration;
@@ -978,15 +978,17 @@ impl Endpoint {
     /// become inaccessible.
     ///
     /// Will return `None` if we do not have any address information for the given `endpoint_id`.
-    pub fn conn_type(&self, endpoint_id: PublicKey) -> Option<n0_watcher::Direct<ConnectionType>> {
-        self.msock.conn_type(endpoint_id)
+    pub fn conn_type(&self, endpoint_id: EndpointId) -> Option<n0_watcher::Direct<ConnectionType>> {
+        let public_key = endpoint_id.as_ed()?;
+        self.msock.conn_type(public_key)
     }
 
     /// Returns the currently lowest latency for this endpoint.
     ///
     /// Will return `None` if we do not have any address information for the given `endpoint_id`.
-    pub fn latency(&self, endpoint_id: PublicKey) -> Option<Duration> {
-        self.msock.latency(endpoint_id)
+    pub fn latency(&self, endpoint_id: EndpointId) -> Option<Duration> {
+        let public_key = endpoint_id.as_ed()?;
+        self.msock.latency(public_key)
     }
 
     /// Returns the DNS resolver used in this [`Endpoint`].
@@ -1968,7 +1970,7 @@ mod tests {
 
         async fn wait_for_conn_type_direct(ep: &Endpoint, endpoint_id: PublicKey) -> Result {
             let mut stream = ep
-                .conn_type(endpoint_id)
+                .conn_type(endpoint_id.into())
                 .expect("connection exists")
                 .stream();
             let src = ep.id().fmt_short();
diff --git a/iroh/src/endpoint/connection.rs b/iroh/src/endpoint/connection.rs
@@ -178,7 +178,7 @@ impl Future for IncomingFuture {
                     Ok(conn) => conn,
                     Err(err) => return Poll::Ready(Err(err.into())),
                 };
-                try_send_rtt_msg(conn.quinn_connection(), this.ep, conn.remote_id());
+                try_send_rtt_msg(conn.quinn_connection(), this.ep, conn.remote_id);
                 Poll::Ready(Ok(conn))
             }
         }
@@ -442,7 +442,7 @@ impl Future for Connecting {
                     }
                 };
 
-                try_send_rtt_msg(conn.quinn_connection(), this.ep, conn.remote_id());
+                try_send_rtt_msg(conn.quinn_connection(), this.ep, conn.remote_id);
                 Poll::Ready(Ok(conn))
             }
         }
@@ -520,7 +520,7 @@ impl Future for Accepting {
                     Err(err) => return Poll::Ready(Err(err.into())),
                 };
 
-                try_send_rtt_msg(conn.quinn_connection(), this.ep, conn.remote_id());
+                try_send_rtt_msg(conn.quinn_connection(), this.ep, conn.remote_id);
                 Poll::Ready(Ok(conn))
             }
         }
@@ -824,8 +824,8 @@ impl OutgoingZeroRttConnection {
     /// connection.
     ///
     /// [`PublicKey`]: iroh_base::PublicKey
-    pub fn remote_id(&self) -> Result<PublicKey, RemoteEndpointIdError> {
-        remote_id_from_quinn_conn(&self.inner)
+    pub fn remote_id(&self) -> Result<EndpointId, RemoteEndpointIdError> {
+        remote_id_from_quinn_conn(&self.inner).map(EndpointId::from)
     }
 
     /// A stable identifier for this connection.
@@ -1135,8 +1135,8 @@ impl IncomingZeroRttConnection {
     /// connection.
     ///
     /// [`PublicKey`]: iroh_base::PublicKey
-    pub fn remote_id(&self) -> Result<PublicKey, RemoteEndpointIdError> {
-        remote_id_from_quinn_conn(&self.inner)
+    pub fn remote_id(&self) -> Result<EndpointId, RemoteEndpointIdError> {
+        remote_id_from_quinn_conn(&self.inner).map(EndpointId::from)
     }
 
     /// A stable identifier for this connection.
@@ -1434,8 +1434,8 @@ impl Connection {
     /// connection.
     ///
     /// [`PublicKey`]: iroh_base::PublicKey
-    pub fn remote_id(&self) -> PublicKey {
-        self.remote_id
+    pub fn remote_id(&self) -> EndpointId {
+        self.remote_id.into()
     }
 
     /// A stable identifier for this connection.
@@ -1495,7 +1495,7 @@ impl Connection {
 /// If we can't notify the actor that will impact performance a little, but we can still
 /// function.
 fn try_send_rtt_msg(conn: &quinn::Connection, ep: &Endpoint, remote_id: PublicKey) {
-    let Some(conn_type_changes) = ep.conn_type(remote_id) else {
+    let Some(conn_type_changes) = ep.conn_type(remote_id.into()) else {
         warn!(?conn, "failed to create conn_type stream");
         return;
     };
diff --git a/iroh/src/protocol.rs b/iroh/src/protocol.rs
@@ -42,7 +42,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use iroh_base::PublicKey;
+use iroh_base::EndpointId;
 use n0_error::{AnyError, e, stack_error};
 use n0_future::{
     join_all,
@@ -558,7 +558,7 @@ async fn handle_connection(incoming: crate::endpoint::Incoming, protocols: Arc<P
 pub struct AccessLimit<P: ProtocolHandler + Clone> {
     proto: P,
     #[debug("limiter")]
-    limiter: Arc<dyn Fn(PublicKey) -> bool + Send + Sync + 'static>,
+    limiter: Arc<dyn Fn(EndpointId) -> bool + Send + Sync + 'static>,
 }
 
 impl<P: ProtocolHandler + Clone> AccessLimit<P> {
@@ -568,7 +568,7 @@ impl<P: ProtocolHandler + Clone> AccessLimit<P> {
     /// connect, and `false` otherwise.
     pub fn new<F>(proto: P, limiter: F) -> Self
     where
-        F: Fn(PublicKey) -> bool + Send + Sync + 'static,
+        F: Fn(EndpointId) -> bool + Send + Sync + 'static,
     {
         Self {
             proto,

Original file line number	Diff line number	Diff line change
`@@ -25,18 +25,16 @@ pub struct PublicKey(CompressedEdwardsY);`
`25`	`25`
`26`	`26`	`/// The identifier for an endpoint in the (iroh) network.`
`27`	`27`	`#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]`
	`28`	`+#[non_exhaustive]`
`28`	`29`	`pub enum EndpointId {`
`29`	`30`	`/// An Ed25519 public key.`
`30`	`31`	`Ed25519(PublicKey),`
`31`		`- /// Other types of endpoint identifiers.`
`32`		`- Other([u8; 8]),`
`33`	`32`	`}`
`34`	`33`
`35`	`34`	`impl PartialEq<PublicKey> for EndpointId {`
`36`	`35`	`fn eq(&self, other: &PublicKey) -> bool {`
`37`	`36`	`match self {`
`38`	`37`	`EndpointId::Ed25519(key) => key == other,`
`39`		`- EndpointId::Other(_) => false,`
`40`	`38`	`}`
`41`	`39`	`}`
`42`	`40`	`}`
`@@ -45,7 +43,6 @@ impl Display for EndpointId {`
`45`	`43`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`46`	`44`	`match self {`
`47`	`45`	`EndpointId::Ed25519(key) => write!(f, "Ed25519({})", key),`
`48`		`- EndpointId::Other(bytes) => write!(f, "Other({})", data_encoding::HEXLOWER.encode(bytes)),`
`49`	`46`	`}`
`50`	`47`	`}`
`51`	`48`	`}`
`@@ -55,7 +52,6 @@ impl EndpointId {`
`55`	`52`	`pub fn as_ed(self) -> Option<PublicKey> {`
`56`	`53`	`match self {`
`57`	`54`	`EndpointId::Ed25519(key) => Some(key),`
`58`		`- EndpointId::Other(_) => None,`
`59`	`55`	`}`
`60`	`56`	`}`
`61`	`57`
`@@ -68,7 +64,6 @@ impl EndpointId {`
`68`	`64`	`pub fn fmt_short(&self) -> String {`
`69`	`65`	`match self {`
`70`	`66`	`EndpointId::Ed25519(key) => key.fmt_short().to_string(),`
`71`		`- EndpointId::Other(_) => "Other".to_string(),`
`72`	`67`	`}`
`73`	`68`	`}`
`74`	`69`	`}`