simplify serde module

ralexstokes · Apr 1, 2024 · 79ae7f1 · 79ae7f1
1 parent d17ae3e
commit 79ae7f1
Show file tree

Hide file tree

Showing 6 changed files with 96 additions and 99 deletions.
diff --git a/ssz-rs/Cargo.toml b/ssz-rs/Cargo.toml
@@ -30,6 +30,7 @@ alloy-primitives = { version = "^0.7.0", default-features = false }
 snap = "1.0"
 project-root = "0.2.2"
 serde_json = "1.0.81"
+hex = "0.4.3"
 
 [build-dependencies]
 sha2 = "0.9.8"
diff --git a/ssz-rs/src/bitlist.rs b/ssz-rs/src/bitlist.rs
@@ -10,6 +10,8 @@ use crate::{
     ser::{Serialize, SerializeError},
     Serializable, SimpleSerialize,
 };
+#[cfg(feature = "serde")]
+use alloy_primitives::Bytes;
 use bitvec::prelude::{BitVec, Lsb0};
 
 const BITS_PER_BYTE: usize = crate::BITS_PER_BYTE as usize;
@@ -260,8 +262,8 @@ impl<const N: usize> serde::Serialize for Bitlist<N> {
     {
         let byte_count = byte_length(self.len());
         let mut buf = Vec::with_capacity(byte_count);
-        let _ = crate::Serialize::serialize(self, &mut buf).map_err(serde::ser::Error::custom)?;
-        crate::serde::as_hex::serialize(&buf, serializer)
+        Serialize::serialize(self, &mut buf).map_err(serde::ser::Error::custom)?;
+        alloy_primitives::serde_hex::serialize(Bytes::from(buf), serializer)
     }
 }
 
@@ -271,7 +273,8 @@ impl<'de, const N: usize> serde::Deserialize<'de> for Bitlist<N> {
     where
         D: serde::Deserializer<'de>,
     {
-        crate::serde::as_hex::deserialize(deserializer)
+        let data: Bytes = alloy_primitives::serde_hex::deserialize(deserializer)?;
+        Self::try_from(data.as_ref()).map_err(serde::de::Error::custom)
     }
 }
 
@@ -365,4 +368,32 @@ mod tests {
         let recovered = Bitlist::<COUNT>::deserialize(&buffer).expect("can decode");
         assert_eq!(input, recovered);
     }
+
+    #[test]
+    fn serde_roundtrip() {
+        let input = Bitlist::<COUNT>::try_from(
+            [
+                false, false, false, true, true, false, false, false, false, false, false, false,
+                false, false, false, true, true, false, false, false, false, false, false, false,
+                true,
+            ]
+            .as_ref(),
+        )
+        .unwrap();
+
+        let serialization = serde_json::to_string(&input).unwrap();
+        let recovered: Bitlist<COUNT> = serde_json::from_str(&serialization).expect("can decode");
+        assert_eq!(input, recovered);
+    }
+
+    #[test]
+    fn serde_bitlist() {
+        let input = Bitlist::<COUNT>::try_from(
+            [true, true, true, true, true, true, true, true, false, true, true, true].as_ref(),
+        )
+        .unwrap();
+
+        let serialization = serde_json::to_string(&input).unwrap();
+        assert_eq!(serialization, "\"0xff1e\"");
+    }
 }
diff --git a/ssz-rs/src/bitvector.rs b/ssz-rs/src/bitvector.rs
@@ -10,6 +10,8 @@ use crate::{
     ser::{Serialize, SerializeError},
     Serializable, SimpleSerialize,
 };
+#[cfg(feature = "serde")]
+use alloy_primitives::Bytes;
 use bitvec::{
     field::BitField,
     prelude::{BitVec, Lsb0},
@@ -243,8 +245,8 @@ impl<const N: usize> serde::Serialize for Bitvector<N> {
         S: serde::Serializer,
     {
         let mut buf = Vec::with_capacity(byte_length(N));
-        let _ = crate::Serialize::serialize(self, &mut buf).map_err(serde::ser::Error::custom)?;
-        crate::serde::as_hex::serialize(&buf, serializer)
+        Serialize::serialize(self, &mut buf).map_err(serde::ser::Error::custom)?;
+        alloy_primitives::serde_hex::serialize(Bytes::from(buf), serializer)
     }
 }
 
@@ -254,7 +256,8 @@ impl<'de, const N: usize> serde::Deserialize<'de> for Bitvector<N> {
     where
         D: serde::Deserializer<'de>,
     {
-        crate::serde::as_hex::deserialize(deserializer)
+        let data: Bytes = alloy_primitives::serde_hex::deserialize(deserializer)?;
+        Self::try_from(data.as_ref()).map_err(serde::de::Error::custom)
     }
 }
 
@@ -319,4 +322,29 @@ mod tests {
         let recovered = Bitvector::<COUNT>::deserialize(&buffer).expect("can decode");
         assert_eq!(input, recovered);
     }
+
+    #[test]
+    fn serde_roundtrip() {
+        let input = Bitvector::<COUNT>::try_from(
+            [false, false, false, true, true, false, false, false, false, false, false, false]
+                .as_ref(),
+        )
+        .unwrap();
+
+        let serialization = serde_json::to_string(&input).unwrap();
+        let recovered: Bitvector<COUNT> = serde_json::from_str(&serialization).expect("can decode");
+        assert_eq!(input, recovered);
+    }
+
+    #[test]
+    fn serde_bitvector() {
+        let input = Bitvector::<COUNT>::try_from(
+            [false, false, false, true, true, false, false, false, false, true, false, false]
+                .as_ref(),
+        )
+        .unwrap();
+
+        let serialization = serde_json::to_string(&input).unwrap();
+        assert_eq!(serialization, "\"0x1802\"");
+    }
 }
diff --git a/ssz-rs/src/lib.rs b/ssz-rs/src/lib.rs
@@ -106,9 +106,6 @@ pub trait Serializable: Serialize + Deserialize {
 pub trait SimpleSerialize: Serializable + HashTreeRoot + GeneralizedIndexable + Prove {}
 
 mod exports {
-    #[cfg(feature = "serde")]
-    pub use alloy_primitives::hex::{self, FromHex};
-
     pub use crate::{
         bitlist::Bitlist,
         bitvector::Bitvector,

diff --git a/ssz-rs/src/serde.rs b/ssz-rs/src/serde.rs
@@ -1,40 +1,40 @@
-use crate::lib::*;
-use alloy_primitives::{hex, hex::FromHexError};
+// use crate::lib::*;
+// use alloy_primitives::{hex, hex::FromHexError};
 
-const HEX_ENCODING_PREFIX: &str = "0x";
+// const HEX_ENCODING_PREFIX: &str = "0x";
 
-pub fn try_bytes_from_hex_str(s: &str) -> Result<Vec<u8>, FromHexError> {
-    let target = s.strip_prefix(HEX_ENCODING_PREFIX).unwrap_or(s);
-    let data = hex::decode(target)?;
-    Ok(data)
-}
+// pub fn try_bytes_from_hex_str(s: &str) -> Result<Vec<u8>, FromHexError> {
+//     let target = s.strip_prefix(HEX_ENCODING_PREFIX).unwrap_or(s);
+//     let data = hex::decode(target)?;
+//     Ok(data)
+// }
 
-pub mod as_hex {
-    use super::*;
-    use serde::Deserialize;
+// pub mod as_hex {
+//     use super::*;
+//     use serde::Deserialize;
 
-    pub fn serialize<S, T: AsRef<[u8]>>(data: T, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let encoding = hex::encode(data.as_ref());
-        let output = format!("{HEX_ENCODING_PREFIX}{encoding}");
-        serializer.collect_str(&output)
-    }
+//     pub fn serialize<S, T: AsRef<[u8]>>(data: T, serializer: S) -> Result<S::Ok, S::Error>
+//     where
+//         S: serde::Serializer,
+//     {
+//         let encoding = hex::encode(data.as_ref());
+//         let output = format!("{HEX_ENCODING_PREFIX}{encoding}");
+//         serializer.collect_str(&output)
+//     }
 
-    pub fn deserialize<'de, D, T, E>(deserializer: D) -> Result<T, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-        T: for<'a> TryFrom<&'a [u8], Error = E>,
-        E: Display,
-    {
-        let str = String::deserialize(deserializer)?;
+//     pub fn deserialize<'de, D, T, E>(deserializer: D) -> Result<T, D::Error>
+//     where
+//         D: serde::Deserializer<'de>,
+//         T: for<'a> TryFrom<&'a [u8], Error = E>,
+//         E: Display,
+//     {
+//         let str = String::deserialize(deserializer)?;
 
-        let data = try_bytes_from_hex_str(&str).map_err(serde::de::Error::custom)?;
+//         let data = try_bytes_from_hex_str(&str).map_err(serde::de::Error::custom)?;
 
-        T::try_from(&data).map_err(serde::de::Error::custom)
-    }
-}
+//         T::try_from(&data).map_err(serde::de::Error::custom)
+//     }
+// }
 
 // pub mod as_str {
 //     use super::*;

diff --git a/ssz-rs/src/utils.rs b/ssz-rs/src/utils.rs
@@ -21,63 +21,3 @@ where
 {
     T::deserialize(encoding)
 }
-
-// #[inline]
-// fn write_hex_from_bytes<D: AsRef<[u8]>>(f: &mut fmt::Formatter<'_>, data: D) -> fmt::Result {
-//     for i in data.as_ref() {
-//         write!(f, "{i:02x}")?;
-//     }
-//     Ok(())
-// }
-
-// pub fn write_bytes_to_lower_hex<T: AsRef<[u8]>>(
-//     f: &mut fmt::Formatter<'_>,
-//     data: T,
-// ) -> fmt::Result {
-//     write!(f, "0x")?;
-//     write_hex_from_bytes(f, data)
-// }
-
-// pub fn write_bytes_to_lower_hex_display<T: AsRef<[u8]> + ExactSizeIterator>(
-//     f: &mut fmt::Formatter<'_>,
-//     data: T,
-// ) -> fmt::Result {
-//     let len = data.len();
-//     let (first, last) = if len >= 4 { ((0..2), Some(len - 2..len)) } else { ((0..len), None) };
-//     let data = data.as_ref();
-//     write!(f, "0x")?;
-//     write_hex_from_bytes(f, &data[first])?;
-//     if let Some(last) = last {
-//         write!(f, "…")?;
-//         write_hex_from_bytes(f, &data[last])?;
-//     }
-//     Ok(())
-// }
-
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
-
-//     struct Fmt(Vec<u8>);
-
-//     impl fmt::Debug for Fmt {
-//         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-//             write_bytes_to_lower_hex(f, self.0.iter())
-//         }
-//     }
-
-//     impl fmt::Display for Fmt {
-//         fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-//             write!(f, "{:?}", self)
-//         }
-//     }
-
-//     #[test]
-//     fn test_fmt() {
-//         let data = Fmt((0u8..3).collect::<Vec<_>>());
-//         let s = format!("{data:?}");
-//         assert_eq!(s, "0x000102");
-//         let s = format!("{data}");
-//         assert_eq!(s, "0x000102");
-//     }
-// }