feat: add serde to peer_id

Signed-off-by: Sacha Froment <[email protected]>

Author: sfroment

Cargo.lock

@@ -4,10 +4,18 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+unsigned-varint = { version = "0.8.0", default-features = false }
+serde = { version = "1.0.116", optional = true, default-features = false }
+
+[dev-dependencies]
+serde_json = "1.0.140"
+serde_bytes = "0.11"
+bincode = { version = "2.0.0-rc.3", features = ["serde"] }
 
 [features]
-default = ["std"]
-std = []
+default = ["std", "serde"]
+std = ["unsigned-varint/std"]
+serde = ["dep:serde"]
 
 [package.metadata.docs.rs]
 all-features = true

sf-peer-id/Cargo.toml

@@ -1,29 +1,96 @@
 use core::fmt;
+use unsigned_varint::decode;
+
+#[cfg(not(feature = "std"))]
+use core2::io;
+#[cfg(feature = "std")]
+use std::io;
 
 /// Error type for parsing a PeerID from a string.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ParsePeerIDError {
+#[derive(Debug)]
+pub enum Error {
     /// The input string had an incorrect length.
     InvalidLength { expected: usize, actual: usize },
     /// The input string contained non-hexadecimal characters or had an odd number of digits.
     InvalidHexEncoding { c: char, index: usize },
+    /// Io error
+    Io(io::Error),
+    /// Varint error
+    Varint(decode::Error),
 }
 
-impl fmt::Display for ParsePeerIDError {
+impl PartialEq for Error {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (
+                Error::InvalidLength { expected, actual },
+                Error::InvalidLength {
+                    expected: e,
+                    actual: a,
+                },
+            ) => expected == e && actual == a,
+            (
+                Error::InvalidHexEncoding { c, index },
+                Error::InvalidHexEncoding { c: cc, index: i },
+            ) => c == cc && index == i,
+            (Error::Io(err), Error::Io(other_err)) => err.kind() == other_err.kind(),
+            (Error::Varint(err), Error::Varint(other_err)) => err == other_err,
+            _ => false,
+        }
+    }
+
+    fn ne(&self, other: &Self) -> bool {
+        !self.eq(other)
+    }
+}
+
+impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ParsePeerIDError::InvalidLength { expected, actual } => {
+            Error::InvalidLength { expected, actual } => {
                 write!(f, "Expected length: {}, but got: {}", expected, actual)
             }
-            ParsePeerIDError::InvalidHexEncoding { c, index } => {
+            Error::InvalidHexEncoding { c, index } => {
                 write!(f, "Invalid hex character '{}' at index {}", c, index)
             }
+            Error::Io(err) => {
+                write!(f, "IO error: {}", err)
+            }
+            Error::Varint(err) => {
+                write!(f, "Varint error: {}", err)
+            }
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+
+impl From<decode::Error> for Error {
+    fn from(err: decode::Error) -> Self {
+        Error::Varint(err)
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<unsigned_varint::io::ReadError> for Error {
+    fn from(err: unsigned_varint::io::ReadError) -> Self {
+        match err {
+            unsigned_varint::io::ReadError::Io(e) => Error::Io(e),
+            unsigned_varint::io::ReadError::Decode(e) => Error::Varint(e),
+            _ => {
+                // This case should not happen, but if it does, we can convert it to a Varint error.
+                Error::Varint(decode::Error::Insufficient)
+            }
         }
     }
 }
 
 #[cfg(feature = "std")]
-impl std::error::Error for ParsePeerIDError {}
+impl std::error::Error for Error {}
 
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
@@ -32,13 +99,86 @@ mod tests {
 
     #[test]
     fn test_parse_id_error_display() {
-        let error = ParsePeerIDError::InvalidLength {
+        let error = Error::InvalidLength {
             expected: 16,
             actual: 20,
         };
         assert_eq!(format!("{}", error), "Expected length: 16, but got: 20");
 
-        let error = ParsePeerIDError::InvalidHexEncoding { c: 'g', index: 5 };
+        let error = Error::InvalidHexEncoding { c: 'g', index: 5 };
         assert_eq!(format!("{}", error), "Invalid hex character 'g' at index 5");
+
+        let io_error = io::Error::new(io::ErrorKind::Other, "IO error");
+        let error = Error::Io(io_error);
+        assert_eq!(format!("{}", error), "IO error: IO error");
+
+        let varint_error = decode::Error::Insufficient;
+        let error = Error::Varint(varint_error);
+        assert_eq!(format!("{}", error), "Varint error: not enough input bytes");
+    }
+
+    #[test]
+    fn test_partial_eq() {
+        let error1 = Error::InvalidLength {
+            expected: 16,
+            actual: 20,
+        };
+        let error2 = Error::InvalidLength {
+            expected: 16,
+            actual: 20,
+        };
+        assert_eq!(error1, error2);
+
+        let error3 = Error::InvalidHexEncoding { c: 'g', index: 5 };
+        assert_ne!(error1, error3);
+
+        let io_error = io::Error::new(io::ErrorKind::Other, "IO error");
+        let error4 = Error::Io(io_error);
+        assert_ne!(error1, error4);
+
+        let varint_error = decode::Error::Insufficient;
+        let error5 = Error::Varint(varint_error);
+        assert_ne!(error1, error5);
+
+        let error6 = Error::Varint(decode::Error::Insufficient);
+        assert_eq!(error5, error6);
+
+        let io_error = io::Error::new(io::ErrorKind::Other, "IO error");
+        let error7 = Error::Io(io_error);
+        assert_eq!(error4, error7);
+
+        assert!(error4 != error5);
+    }
+
+    #[test]
+    fn test_error_from_io() {
+        let err = io::Error::new(io::ErrorKind::Other, "IO error");
+        let error = Error::from(err);
+        assert_eq!(
+            error,
+            Error::Io(io::Error::new(io::ErrorKind::Other, "IO error"))
+        );
+    }
+
+    #[test]
+    fn test_error_from_varint() {
+        let varint_error = decode::Error::Insufficient;
+        let error: Error = Error::from(varint_error);
+        assert_eq!(error, Error::Varint(decode::Error::Insufficient));
+    }
+
+    #[test]
+    fn test_error_from_unsigned_varint_io() {
+        let read_error =
+            unsigned_varint::io::ReadError::Io(io::Error::new(io::ErrorKind::Other, "IO error"));
+        let error: Error = Error::from(read_error);
+        assert_eq!(
+            error,
+            Error::Io(io::Error::new(io::ErrorKind::Other, "IO error"))
+        );
+
+        let decode_error = unsigned_varint::io::ReadError::Decode(decode::Error::Insufficient);
+        let error: Error = Error::from(decode_error);
+        assert_eq!(error, Error::Varint(decode::Error::Insufficient));
     }
 }

sf-peer-id/src/error.rs

@@ -1,12 +1,12 @@
-use crate::ParsePeerIDError;
+use crate::Error;
 
 #[inline]
-pub(crate) fn hex_char_to_value(c: char, i: usize) -> Result<u8, ParsePeerIDError> {
+pub(crate) fn hex_char_to_value(c: char, i: usize) -> Result<u8, Error> {
     match c {
         '0'..='9' => Ok((c as u8) - b'0'),
         'a'..='f' => Ok((c as u8) - b'a' + 10),
         'A'..='F' => Ok((c as u8) - b'A' + 10),
-        _ => Err(ParsePeerIDError::InvalidHexEncoding { c, index: i }),
+        _ => Err(Error::InvalidHexEncoding { c, index: i }),
     }
 }
 
@@ -25,7 +25,7 @@ mod tests {
         assert_eq!(hex_char_to_value('F', 0), Ok(15));
         assert_eq!(
             hex_char_to_value('g', 0),
-            Err(ParsePeerIDError::InvalidHexEncoding { c: 'g', index: 0 })
+            Err(Error::InvalidHexEncoding { c: 'g', index: 0 })
         );
     }
 }

sf-peer-id/src/hex.rs

@@ -4,7 +4,12 @@
 mod error;
 mod hex;
 mod peer_id;
+#[cfg(feature = "serde")]
+mod serde;
 
 pub(crate) use crate::hex::hex_char_to_value;
 
-pub use crate::{error::ParsePeerIDError, peer_id::PeerID};
+pub use crate::{
+    error::Error,
+    peer_id::{FixedSizePeerID, PeerID},
+};