Introducing serde-secrets feature flag

Author: dr-orlovsky

Cargo.toml

@@ -27,6 +27,7 @@ recovery = ["secp256k1-sys/recovery"]
 lowmemory = ["secp256k1-sys/lowmemory"]
 global-context = ["std", "rand-std", "global-context-less-secure"]
 global-context-less-secure = []
+serde-secrets = ["serde", "std"]
 
 [dependencies]
 secp256k1-sys = { version = "0.4.1", default-features = false, path = "./secp256k1-sys" }

contrib/test.sh

@@ -1,6 +1,6 @@
 #!/bin/sh -ex
 
-FEATURES="bitcoin_hashes global-context lowmemory rand rand-std recovery serde"
+FEATURES="bitcoin_hashes global-context lowmemory rand rand-std recovery serde serde-secrets"
 
 # Use toolchain if explicitly specified
 if [ -n "$TOOLCHAIN" ]

src/key.rs

@@ -199,7 +199,7 @@ impl SecretKey {
     }
 }
 
-#[cfg(feature = "serde")]
+#[cfg(all(feature = "serde", feature = "serde-secrets"))]
 impl ::serde::Serialize for SecretKey {
     fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         if s.is_human_readable() {
@@ -933,17 +933,14 @@ mod test {
 
     #[cfg(feature = "serde")]
     #[test]
-    fn test_serde() {
+    fn test_serde_pk() {
         use serde_test::{Configure, Token, assert_tokens};
         static SK_BYTES: [u8; 32] = [
             1, 1, 1, 1, 1, 1, 1, 1,
             0, 1, 2, 3, 4, 5, 6, 7,
             0xff, 0xff, 0, 0, 0xff, 0xff, 0, 0,
             99, 99, 99, 99, 99, 99, 99, 99
         ];
-        static SK_STR: &'static str = "\
-            01010101010101010001020304050607ffff0000ffff00006363636363636363\
-        ";
         static PK_BYTES: [u8; 33] = [
             0x02,
             0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f,
@@ -965,21 +962,37 @@ mod test {
         #[cfg(fuzzing)]
         let pk = PublicKey::from_slice(&PK_BYTES).expect("pk");
 
-        assert_tokens(&sk.compact(), &[Token::BorrowedBytes(&SK_BYTES[..])]);
-        assert_tokens(&sk.compact(), &[Token::Bytes(&SK_BYTES)]);
-        assert_tokens(&sk.compact(), &[Token::ByteBuf(&SK_BYTES)]);
-
-        assert_tokens(&sk.readable(), &[Token::BorrowedStr(SK_STR)]);
-        assert_tokens(&sk.readable(), &[Token::Str(SK_STR)]);
-        assert_tokens(&sk.readable(), &[Token::String(SK_STR)]);
-
         assert_tokens(&pk.compact(), &[Token::BorrowedBytes(&PK_BYTES[..])]);
         assert_tokens(&pk.compact(), &[Token::Bytes(&PK_BYTES)]);
         assert_tokens(&pk.compact(), &[Token::ByteBuf(&PK_BYTES)]);
 
         assert_tokens(&pk.readable(), &[Token::BorrowedStr(PK_STR)]);
         assert_tokens(&pk.readable(), &[Token::Str(PK_STR)]);
         assert_tokens(&pk.readable(), &[Token::String(PK_STR)]);
+    }
+
+    #[cfg(all(feature = "serde", feature = "serde-secrets"))]
+    #[test]
+    fn test_serde_sk() {
+        use serde_test::{Configure, Token, assert_tokens};
+        static SK_BYTES: [u8; 32] = [
+            1, 1, 1, 1, 1, 1, 1, 1,
+            0, 1, 2, 3, 4, 5, 6, 7,
+            0xff, 0xff, 0, 0, 0xff, 0xff, 0, 0,
+            99, 99, 99, 99, 99, 99, 99, 99
+        ];
+        static SK_STR: &'static str = "\
+            01010101010101010001020304050607ffff0000ffff00006363636363636363\
+        ";
+
+        let sk = SecretKey::from_slice(&SK_BYTES).unwrap();
+
+        assert_tokens(&sk.clone().compact(), &[Token::BorrowedBytes(&SK_BYTES[..])]);
+        assert_tokens(&sk.clone().compact(), &[Token::Bytes(&SK_BYTES)]);
+        assert_tokens(&sk.clone().compact(), &[Token::ByteBuf(&SK_BYTES)]);
 
+        assert_tokens(&sk.clone().readable(), &[Token::BorrowedStr(SK_STR)]);
+        assert_tokens(&sk.clone().readable(), &[Token::Str(SK_STR)]);
+        assert_tokens(&sk.clone().readable(), &[Token::String(SK_STR)]);
     }
 }

src/lib.rs

@@ -795,7 +795,7 @@ impl<C: Verification> Secp256k1<C> {
     /// which OpenSSL would verify but not libsecp256k1, or vice-versa. Requires a
     /// verify-capable context.
     ///
-    /// ```rust
+    /// ```
     /// # #[cfg(feature="rand")] {
     /// # use secp256k1::rand::rngs::OsRng;
     /// # use secp256k1::{Secp256k1, Message, Error};