Serialization with serde.

substrate/primitives/src/hash.rs

@@ -16,5 +16,100 @@
 
 //! A fixed hash type.
 
+use std::fmt;
+use serde::{de, Serialize, Serializer, Deserialize, Deserializer};
+
+macro_rules! impl_serde {
+	($name: ident, $len: expr) => {
+		impl Serialize for $name {
+			fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+				// TODO [ToDr] Use raw bytes if we switch to RLP / binencoding
+				// (serialize_bytes)
+				serializer.serialize_str(&format!("0x{:?}", self))
+
+			}
+		}
+
+		impl<'de> Deserialize<'de> for $name {
+			fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+				struct Visitor;
+				impl<'a> de::Visitor<'a> for Visitor {
+					type Value = $name;
+
+					fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+						write!(formatter, "a 0x-prefixed hex string of {} bytes", $len)
+					}
+
+					fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
+						if v.len() < 2  || &v[0..2] != "0x" {
+							return Err(E::custom("prefix is missing"))
+						}
+
+						// 0x + len
+						if v.len() != 2 + $len * 2 {
+							return Err(E::invalid_length(v.len() - 2, &self));
+						}
+
+						let bytes = ::rustc_hex::FromHex::from_hex(&v[2..])
+							.map_err(|e| E::custom(&format!("invalid hex value: {:?}", e)))?;
+						Ok((&*bytes).into())
+					}
+
+					fn visit_string<E: de::Error>(self, v: String) -> Result<Self::Value, E> {
+						self.visit_str(&v)
+					}
+				}
+				// TODO [ToDr] Use raw bytes if we switch to RLP / binencoding
+				// (visit_bytes, visit_bytes_buf)
+				deserializer.deserialize_str(Visitor)
+			}
+		}
+	}
+}
+
 impl_hash!(H160, 20);
+impl_serde!(H160, 20);
 impl_hash!(H256, 32);
+impl_serde!(H256, 32);
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use polkadot_serializer as ser;
+
+	#[test]
+	fn test_h160() {
+		let tests = vec![
+			(H160::from(0), "0x0000000000000000000000000000000000000000"),
+			(H160::from(2), "0x0000000000000000000000000000000000000002"),
+			(H160::from(15), "0x000000000000000000000000000000000000000f"),
+			(H160::from(16), "0x0000000000000000000000000000000000000010"),
+			(H160::from(1_000), "0x00000000000000000000000000000000000003e8"),
+			(H160::from(100_000), "0x00000000000000000000000000000000000186a0"),
+			(H160::from(u64::max_value()), "0x000000000000000000000000ffffffffffffffff"),
+		];
+
+		for (number, expected) in tests {
+			assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
+			assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
+		}
+	}
+
+	#[test]
+	fn test_h256() {
+		let tests = vec![
+			(H256::from(0), "0x0000000000000000000000000000000000000000000000000000000000000000"),
+			(H256::from(2), "0x0000000000000000000000000000000000000000000000000000000000000002"),
+			(H256::from(15), "0x000000000000000000000000000000000000000000000000000000000000000f"),
+			(H256::from(16), "0x0000000000000000000000000000000000000000000000000000000000000010"),
+			(H256::from(1_000), "0x00000000000000000000000000000000000000000000000000000000000003e8"),
+			(H256::from(100_000), "0x00000000000000000000000000000000000000000000000000000000000186a0"),
+			(H256::from(u64::max_value()), "0x000000000000000000000000000000000000000000000000ffffffffffffffff"),
+		];
+
+		for (number, expected) in tests {
+			assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
+			assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
+		}
+	}
+}