Merge pull request #596 from RCasatta/script_ser

src/blockdata/script.rs

@@ -823,44 +823,59 @@ impl_index_newtype!(Builder, u8);
 #[cfg(feature = "serde")]
 impl<'de> serde::Deserialize<'de> for Script {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
+    where D: serde::Deserializer<'de>,
-        D: serde::Deserializer<'de>,
     {
         use core::fmt::Formatter;
         use hashes::hex::FromHex;
 
+        if deserializer.is_human_readable() {
+
             struct Visitor;
             impl<'de> serde::de::Visitor<'de> for Visitor {
                 type Value = Script;
 
                 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                formatter.write_str("a script")
+                    formatter.write_str("a script hex")
                 }
 
                 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
+                    where E: serde::de::Error,
-                E: serde::de::Error,
                 {
                     let v = Vec::from_hex(v).map_err(E::custom)?;
                     Ok(Script::from(v))
                 }
 
                 fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-            where
+                    where E: serde::de::Error,
-                E: serde::de::Error,
                 {
                     self.visit_str(v)
                 }
 
                 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-            where
+                    where E: serde::de::Error,
-                E: serde::de::Error,
                 {
                     self.visit_str(&v)
                 }
             }
-
             deserializer.deserialize_str(Visitor)
+        } else {
+            struct BytesVisitor;
+
+            impl<'de> serde::de::Visitor<'de> for BytesVisitor {
+                type Value = Script;
+
+                fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                    formatter.write_str("a script Vec<u8>")
+                }
+
+                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                    where E: serde::de::Error,
+                {
+                    Ok(Script::from(v.to_vec()))
+                }
+            }
+            deserializer.deserialize_bytes(BytesVisitor)
+        }
     }
 }
 
@@ -871,7 +886,11 @@ impl serde::Serialize for Script {
     where
         S: serde::Serializer,
     {
+        if serializer.is_human_readable() {
             serializer.serialize_str(&format!("{:x}", self))
+        } else {
+            serializer.serialize_bytes(&self.as_bytes())
+        }
     }
 }
 
@@ -1278,5 +1297,22 @@ mod test {
         assert!(script_p2pkh.is_p2pkh());
         assert_eq!(script_p2pkh.dust_value(), ::Amount::from_sat(546));
     }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_script_serde_human_and_not() {
+        let script = Script::from(vec![0u8, 1u8, 2u8]);
+
+        // Serialize
+        let json = ::serde_json::to_string(&script).unwrap();
+        assert_eq!(json, "\"000102\"");
+        let bincode = ::bincode::serialize(&script).unwrap();
+        assert_eq!(bincode, [3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2]); // bincode adds u64 for length, serde_cbor use varint
+
+        // Deserialize
+        assert_eq!(script, ::serde_json::from_str(&json).unwrap());
+        assert_eq!(script, ::bincode::deserialize(&bincode).unwrap());
+    }
+
 }