refactor: use hex for debugging and display

Everything except the ticket in the examples is now using hex

Ref n0-computer/iroh#2841

Cargo.toml

@@ -50,6 +50,8 @@ iroh-net = { version = "0.27.0", optional = true, default-features = false }
 tokio = { version = "1", optional = true, features = ["io-util", "sync", "rt", "macros", "net", "fs"] }
 tokio-util = { version = "0.7.12", optional = true, features = ["codec", "rt"] }
 tracing = "0.1"
+data-encoding = { version = "2.6.0", optional = true }
+hex = "0.4.3"
 
 [dev-dependencies]
 clap = { version = "4", features = ["derive"] }
@@ -71,9 +73,11 @@ net = [
     "dep:futures-concurrency"
 ]
 
+examples = ["net", "dep:data-encoding"]
+
 [[example]]
 name = "chat"
-required-features = ["net"]
+required-features = ["examples"]
 
 [package.metadata.docs.rs]
 all-features = true

examples/chat.rs

@@ -10,7 +10,6 @@ use bytes::Bytes;
 use clap::Parser;
 use ed25519_dalek::Signature;
 use futures_lite::StreamExt;
-use iroh_base::base32;
 use iroh_gossip::{
     net::{Event, Gossip, GossipEvent, GossipReceiver, GOSSIP_ALPN},
     proto::TopicId,
@@ -61,7 +60,7 @@ enum Command {
     ///
     /// If no topic is provided, a new topic will be created.
     Open {
-        /// Optionally set the topic id (32 bytes, as base32 string).
+        /// Optionally set the topic id (64 bytes, as hex string).
         topic: Option<TopicId>,
     },
     /// Join a chat room from a ticket.
@@ -297,15 +296,18 @@ impl Ticket {
 /// Serializes to base32.
 impl fmt::Display for Ticket {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", base32::fmt(self.to_bytes()))
+        let mut text = data_encoding::BASE32_NOPAD.encode(&self.to_bytes()[..]);
+        text.make_ascii_lowercase();
+        write!(f, "{}", text)
     }
 }
 
 /// Deserializes from base32.
 impl FromStr for Ticket {
     type Err = anyhow::Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::from_bytes(&base32::parse_vec(s)?)
+        let bytes = data_encoding::BASE32_NOPAD.decode(s.to_ascii_uppercase().as_bytes())?;
+        Self::from_bytes(&bytes)
     }
 }
 

src/proto/util.rs

@@ -34,20 +34,22 @@ macro_rules! idbytes_impls {
 
         impl ::std::fmt::Display for $ty {
             fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                write!(f, "{}", ::iroh_base::base32::fmt(&self.0))
+                write!(f, "{}", ::hex::encode(&self.0))
             }
         }
 
         impl ::std::fmt::Debug for $ty {
             fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                write!(f, "{}({})", $name, ::iroh_base::base32::fmt_short(&self.0))
+                write!(f, "{}({})", $name, ::hex::encode(&self.0))
             }
         }
 
         impl ::std::str::FromStr for $ty {
             type Err = ::anyhow::Error;
             fn from_str(s: &str) -> ::std::result::Result<Self, Self::Err> {
-                Ok(Self::from_bytes(::iroh_base::base32::parse_array(s)?))
+                let mut bytes = [0u8; 32];
+                ::hex::decode_to_slice(s, &mut bytes)?;
+                Ok(Self::from_bytes(bytes))
             }
         }
 
@@ -423,17 +425,20 @@ mod test {
     }
 
     #[test]
-    fn base32() {
+    fn hex() {
         #[derive(Eq, PartialEq)]
         struct Id([u8; 32]);
         idbytes_impls!(Id, "Id");
         let id: Id = [1u8; 32].into();
         assert_eq!(id, Id::from_str(&format!("{id}")).unwrap());
         assert_eq!(
             &format!("{id}"),
-            "aeaqcaibaeaqcaibaeaqcaibaeaqcaibaeaqcaibaeaqcaibaeaq"
+            "0101010101010101010101010101010101010101010101010101010101010101"
+        );
+        assert_eq!(
+            &format!("{id:?}"),
+            "Id(0101010101010101010101010101010101010101010101010101010101010101)"
         );
-        assert_eq!(&format!("{id:?}"), "Id(aeaqcaibaeaqcaib)");
         assert_eq!(id.as_bytes(), &[1u8; 32]);
     }