Serde: use hex encoding for BitcoinNodeHash when (de)serializer is human-readable

Author: Ash-L2L

src/accumulator/node_hash.rs

@@ -52,6 +52,7 @@ use std::ops::Deref;
 use std::str::FromStr;
 
 use bitcoin_hashes::hex;
+use bitcoin_hashes::hex::DisplayHex;
 use bitcoin_hashes::sha256;
 use bitcoin_hashes::sha512_256;
 use bitcoin_hashes::Hash;
@@ -77,6 +78,51 @@ pub trait AccumulatorHash:
         R: std::io::Read;
 }
 
+/// (de)serialize as hex if the (de)serializer is human readable.
+#[cfg(feature = "with-serde")]
+mod serde_hex {
+    pub fn serialize<S, T>(data: T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+        T: serde::Serialize + bitcoin_hashes::hex::DisplayHex,
+    {
+        if serializer.is_human_readable() {
+            serializer.collect_str(&format_args!("{:x}", data.as_hex()))
+        } else {
+            data.serialize(serializer)
+        }
+    }
+
+    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+        T: serde::Deserialize<'de> + bitcoin_hashes::hex::FromHex,
+    {
+        struct HexVisitor<T>(std::marker::PhantomData<T>);
+
+        impl<'de, T> serde::de::Visitor<'de> for HexVisitor<T>
+        where
+            T: bitcoin_hashes::hex::FromHex,
+        {
+            type Value = T;
+
+            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                f.write_str("an ASCII hex string")
+            }
+
+            fn visit_str<E: serde::de::Error>(self, data: &str) -> Result<Self::Value, E> {
+                T::from_hex(data).map_err(serde::de::Error::custom)
+            }
+        }
+
+        if deserializer.is_human_readable() {
+            deserializer.deserialize_map(HexVisitor(std::marker::PhantomData))
+        } else {
+            T::deserialize(deserializer)
+        }
+    }
+}
+
 #[derive(Eq, PartialEq, Copy, Clone, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 /// AccumulatorHash is a wrapper around a 32 byte array that represents a hash of a node in the tree.
@@ -94,7 +140,7 @@ pub enum BitcoinNodeHash {
     #[default]
     Empty,
     Placeholder,
-    Some([u8; 32]),
+    Some(#[cfg_attr(feature = "with-serde", serde(with = "serde_hex"))] [u8; 32]),
 }
 
 #[deprecated(since = "0.4.0", note = "Please use BitcoinNodeHash instead.")]
@@ -114,11 +160,7 @@ impl Deref for BitcoinNodeHash {
 impl Display for BitcoinNodeHash {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         if let BitcoinNodeHash::Some(ref inner) = self {
-            let mut s = String::new();
-            for byte in inner.iter() {
-                s.push_str(&format!("{:02x}", byte));
-            }
-            write!(f, "{}", s)
+            Display::fmt(&inner.as_hex(), f)
         } else {
             write!(f, "empty")
         }
@@ -130,13 +172,7 @@ impl Debug for BitcoinNodeHash {
         match self {
             BitcoinNodeHash::Empty => write!(f, "empty"),
             BitcoinNodeHash::Placeholder => write!(f, "placeholder"),
-            BitcoinNodeHash::Some(ref inner) => {
-                let mut s = String::new();
-                for byte in inner.iter() {
-                    s.push_str(&format!("{:02x}", byte));
-                }
-                write!(f, "{}", s)
-            }
+            BitcoinNodeHash::Some(ref inner) => Debug::fmt(&inner.as_hex(), f),
         }
     }
 }