Merge #34: Implement serde for EcdsaAdaptorSignature

f089aea Implement serde for EcdsaAdaptorSignature (Lucas Soriano del Pino)
5a4f874 Define deserialization from string and bytes generically (Lucas Soriano del Pino)

Pull request description:

ACKs for top commit:
  thomaseizinger:
    ACK f089aea
  jonasnick:
    ACK f089aea

Tree-SHA512: c1cbfda5b2b1e54973140cda8e6a1a4aa5b12730e78ded37a4686b16cb4f337bd4bda6fcceba308965cef7c191a37667c25b23732bc0a21e6582fa70f56f3c6f

Author: jonasnick

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 - Rename `secp256k1_zkp::bitcoin_hashes` module to `secp256k1_zkp::hashes`.
 - Rename feature `hashes` to `bitcoin_hashes` to align with `rust-secp256k1`.
+- Implement `serde::{Serialize, Deserialize}` for `EcdsaAdaptorSignature`.
 
 # 0.4.0 - 2021-05-04
 

src/lib.rs

@@ -74,6 +74,8 @@ pub use key::{PublicKey, SecretKey};
 
 pub use secp256k1::*;
 
+#[cfg(feature = "serde")]
+mod serde_util;
 mod zkp;
 pub use zkp::*;
 

src/serde_util.rs

@@ -0,0 +1,69 @@
+use core::fmt;
+use core::marker::PhantomData;
+use core::str::{self, FromStr};
+use serde::de;
+
+/// A serde visitor that works for `T`s implementing `FromStr`.
+pub struct FromStrVisitor<T> {
+    expectation: &'static str,
+    _pd: PhantomData<T>,
+}
+
+impl<T> FromStrVisitor<T> {
+    pub fn new(expectation: &'static str) -> Self {
+        FromStrVisitor {
+            expectation,
+            _pd: PhantomData,
+        }
+    }
+}
+
+impl<'de, T> de::Visitor<'de> for FromStrVisitor<T>
+where
+    T: FromStr,
+    <T as FromStr>::Err: fmt::Display,
+{
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str(self.expectation)
+    }
+
+    fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
+        FromStr::from_str(v).map_err(E::custom)
+    }
+}
+
+pub struct BytesVisitor<F> {
+    expectation: &'static str,
+    parse_fn: F,
+}
+
+impl<F, T, Err> BytesVisitor<F>
+where
+    F: FnOnce(&[u8]) -> Result<T, Err>,
+    Err: fmt::Display,
+{
+    pub fn new(expectation: &'static str, parse_fn: F) -> Self {
+        BytesVisitor {
+            expectation,
+            parse_fn,
+        }
+    }
+}
+
+impl<'de, F, T, Err> de::Visitor<'de> for BytesVisitor<F>
+where
+    F: FnOnce(&[u8]) -> Result<T, Err>,
+    Err: fmt::Display,
+{
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str(self.expectation)
+    }
+
+    fn visit_bytes<E: de::Error>(self, v: &[u8]) -> Result<Self::Value, E> {
+        (self.parse_fn)(v).map_err(E::custom)
+    }
+}

src/zkp/ecdsa_adaptor.rs

@@ -50,6 +50,33 @@ impl str::FromStr for EcdsaAdaptorSignature {
     }
 }
 
+#[cfg(feature = "serde")]
+impl ::serde::Serialize for EcdsaAdaptorSignature {
+    fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        if s.is_human_readable() {
+            s.collect_str(self)
+        } else {
+            s.serialize_bytes(self.0.as_bytes())
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> ::serde::Deserialize<'de> for EcdsaAdaptorSignature {
+    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        use serde_util;
+
+        if d.is_human_readable() {
+            d.deserialize_str(serde_util::FromStrVisitor::new("an ASCII hex string"))
+        } else {
+            d.deserialize_bytes(serde_util::BytesVisitor::new(
+                "a bytestring",
+                EcdsaAdaptorSignature::from_slice,
+            ))
+        }
+    }
+}
+
 impl CPtr for EcdsaAdaptorSignature {
     type Target = ffi::EcdsaAdaptorSignature;
     fn as_c_ptr(&self) -> *const Self::Target {
@@ -409,6 +436,49 @@ mod tests {
         assert_eq!(expected_decryption_key, recovered);
     }
 
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_ecdsa_adaptor_sig_de_serialization() {
+        use serde_test::Configure;
+        use serde_test::{assert_tokens, Token};
+
+        let sig = EcdsaAdaptorSignature::from_slice(&[
+            3, 44, 99, 124, 215, 151, 221, 140, 44, 226, 97, 144, 126, 212, 62, 130, 214, 209, 164,
+            140, 186, 187, 190, 206, 128, 17, 51, 221, 141, 112, 160, 27, 20, 3, 235, 97, 90, 62,
+            89, 177, 203, 191, 79, 135, 172, 175, 100, 91, 225, 237, 163, 42, 6, 102, 17, 243, 93,
+            213, 85, 120, 2, 128, 43, 20, 177, 156, 129, 192, 76, 63, 239, 172, 87, 131, 178, 7,
+            123, 212, 63, 160, 163, 154, 184, 166, 77, 77, 120, 51, 42, 93, 98, 30, 162, 62, 202,
+            70, 188, 1, 16, 17, 171, 130, 221, 166, 222, 184, 86, 153, 245, 8, 116, 77, 112, 212,
+            19, 75, 234, 3, 247, 132, 210, 133, 181, 198, 193, 90, 86, 228, 225, 250, 180, 188, 53,
+            106, 187, 222, 187, 59, 143, 225, 229, 94, 109, 214, 210, 169, 234, 69, 126, 145, 178,
+            230, 100, 47, 174, 105, 249, 219, 181, 37, 136, 84,
+        ])
+        .unwrap();
+
+        assert_tokens(
+            &sig.readable(),
+            &[Token::Str(
+                "032c637cd797dd8c2ce261907ed43e82d6d1a48cbabbbece801133dd8d70a01b1403eb615a3e59b1cbbf4f87acaf645be1eda32a066611f35dd5557802802b14b19c81c04c3fefac5783b2077bd43fa0a39ab8a64d4d78332a5d621ea23eca46bc011011ab82dda6deb85699f508744d70d4134bea03f784d285b5c6c15a56e4e1fab4bc356abbdebb3b8fe1e55e6dd6d2a9ea457e91b2e6642fae69f9dbb5258854",
+            )],
+        );
+
+        assert_tokens(
+            &sig.compact(),
+            &[Token::Bytes(&[
+                3, 44, 99, 124, 215, 151, 221, 140, 44, 226, 97, 144, 126, 212, 62, 130, 214, 209,
+                164, 140, 186, 187, 190, 206, 128, 17, 51, 221, 141, 112, 160, 27, 20, 3, 235, 97,
+                90, 62, 89, 177, 203, 191, 79, 135, 172, 175, 100, 91, 225, 237, 163, 42, 6, 102,
+                17, 243, 93, 213, 85, 120, 2, 128, 43, 20, 177, 156, 129, 192, 76, 63, 239, 172,
+                87, 131, 178, 7, 123, 212, 63, 160, 163, 154, 184, 166, 77, 77, 120, 51, 42, 93,
+                98, 30, 162, 62, 202, 70, 188, 1, 16, 17, 171, 130, 221, 166, 222, 184, 86, 153,
+                245, 8, 116, 77, 112, 212, 19, 75, 234, 3, 247, 132, 210, 133, 181, 198, 193, 90,
+                86, 228, 225, 250, 180, 188, 53, 106, 187, 222, 187, 59, 143, 225, 229, 94, 109,
+                214, 210, 169, 234, 69, 126, 145, 178, 230, 100, 47, 174, 105, 249, 219, 181, 37,
+                136, 84,
+            ])],
+        );
+    }
+
     fn msg_from_str(input: &str) -> Message {
         let mut buf = [0u8; 32];
         from_hex(input, &mut buf).unwrap();

src/zkp/generator.rs

@@ -223,54 +223,15 @@ impl ::serde::Serialize for Generator {
 #[cfg(feature = "serde")]
 impl<'de> ::serde::Deserialize<'de> for Generator {
     fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-        if d.is_human_readable() {
-            struct HexVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                type Value = Generator;
+        use serde_util;
 
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("an ASCII hex string")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    if let Ok(hex) = str::from_utf8(v) {
-                        str::FromStr::from_str(hex).map_err(E::custom)
-                    } else {
-                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
-                    }
-                }
-
-                fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    str::FromStr::from_str(v).map_err(E::custom)
-                }
-            }
-            d.deserialize_str(HexVisitor)
+        if d.is_human_readable() {
+            d.deserialize_str(serde_util::FromStrVisitor::new("an ASCII hex string"))
         } else {
-            struct BytesVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                type Value = Generator;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("a bytestring")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    Generator::from_slice(v).map_err(E::custom)
-                }
-            }
-
-            d.deserialize_bytes(BytesVisitor)
+            d.deserialize_bytes(serde_util::BytesVisitor::new(
+                "a bytestring",
+                Generator::from_slice,
+            ))
         }
     }
 }
@@ -289,54 +250,15 @@ impl ::serde::Serialize for Tweak {
 #[cfg(feature = "serde")]
 impl<'de> ::serde::Deserialize<'de> for Tweak {
     fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-        if d.is_human_readable() {
-            struct HexVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                type Value = Tweak;
+        use serde_util;
 
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("an ASCII hex string")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    if let Ok(hex) = str::from_utf8(v) {
-                        str::FromStr::from_str(hex).map_err(E::custom)
-                    } else {
-                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
-                    }
-                }
-
-                fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    str::FromStr::from_str(v).map_err(E::custom)
-                }
-            }
-            d.deserialize_str(HexVisitor)
+        if d.is_human_readable() {
+            d.deserialize_str(serde_util::FromStrVisitor::new("an ASCII hex string"))
         } else {
-            struct BytesVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                type Value = Tweak;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("a bytestring")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    Tweak::from_slice(v).map_err(E::custom)
-                }
-            }
-
-            d.deserialize_bytes(BytesVisitor)
+            d.deserialize_bytes(serde_util::BytesVisitor::new(
+                "a bytestring",
+                Tweak::from_slice,
+            ))
         }
     }
 }

src/zkp/pedersen.rs

@@ -219,54 +219,15 @@ impl ::serde::Serialize for PedersenCommitment {
 #[cfg(feature = "serde")]
 impl<'de> ::serde::Deserialize<'de> for PedersenCommitment {
     fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        use serde_util;
+
         if d.is_human_readable() {
-            struct HexVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                type Value = PedersenCommitment;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("an ASCII hex string")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    if let Ok(hex) = str::from_utf8(v) {
-                        str::FromStr::from_str(hex).map_err(E::custom)
-                    } else {
-                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
-                    }
-                }
-
-                fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    str::FromStr::from_str(v).map_err(E::custom)
-                }
-            }
-            d.deserialize_str(HexVisitor)
+            d.deserialize_str(serde_util::FromStrVisitor::new("an ASCII hex string"))
         } else {
-            struct BytesVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                type Value = PedersenCommitment;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("a bytestring")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    PedersenCommitment::from_slice(v).map_err(E::custom)
-                }
-            }
-
-            d.deserialize_bytes(BytesVisitor)
+            d.deserialize_bytes(serde_util::BytesVisitor::new(
+                "a bytestring",
+                PedersenCommitment::from_slice,
+            ))
         }
     }
 }