serde: add stringify serializer over generic T:Display

Cargo.toml

@@ -40,6 +40,7 @@ getrandom = { version = "0.2", features = ["js"] }
 simplicity-sys = { version = "0.6.1", path = "./simplicity-sys", features = [
     "test-utils",
 ] }
+serde_test = "1"
 
 [workspace]
 members = ["simpcli", "simplicity-sys", "fuzz"]

src/lib.rs

@@ -65,8 +65,6 @@
 pub extern crate bitcoin;
 #[cfg(feature = "elements")]
 pub extern crate elements;
-#[cfg(feature = "serde")]
-pub extern crate serde;
 
 /// Re-export of base64 crate
 #[cfg(feature = "base64")]
@@ -96,6 +94,8 @@ mod merkle;
 pub mod node;
 #[cfg(feature = "elements")]
 pub mod policy;
+#[cfg(feature = "serde")]
+pub mod serde;
 pub mod types;
 mod value;
 

src/serde/mod.rs

@@ -0,0 +1,3 @@
+// re-export of the serde crate
+pub use ::serde::*;
+pub mod stringify;

src/serde/stringify.rs

@@ -0,0 +1,58 @@
+use std::fmt::Display;
+
+use serde::Serializer;
+
+/// A generic serializer that serializes any type T: Display as a string and can
+/// be used with `#[serde(with = "simplicity::serde::stringify")` over a struct
+/// field.
+///```rust
+/// #[derive(serde::Serialize)]
+/// struct Foo {
+///    #[serde(with = "simplicity::serde::stringify")]
+///     v: simplicity::Value,
+/// }
+///```
+pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: Display,
+{
+    serializer.serialize_str(&value.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::Value;
+    use serde::Serialize;
+    use serde_test::{assert_ser_tokens, Token};
+
+    #[test]
+    fn can_stringify_value() {
+        #[derive(Serialize)]
+        struct Foo {
+            #[serde(with = "crate::serde::stringify")]
+            v: Value,
+        }
+
+        // values taken from Value's `value_display` test
+        let value_string_pairs = [
+            (Value::u1(0), "0b0"),
+            (Value::u1(1), "0b1"),
+            (Value::u4(6), "0x6"),
+        ];
+        for (v, want) in value_string_pairs {
+            assert_ser_tokens(
+                &Foo { v },
+                &[
+                    Token::Struct {
+                        name: "Foo",
+                        len: 1,
+                    },
+                    Token::Str("v"),
+                    Token::Str(want),
+                    Token::StructEnd,
+                ],
+            );
+        }
+    }
+}