[ref] serde must be an optional feature

Cargo.toml

@@ -18,7 +18,7 @@ bs58 = "0.3.0"
 byteorder = "1.3.2"
 ring = "0.16.9"
 scrypt = { version = "0.2", default-features = false }
-serde = { version = "1.0.*", features = ["derive"] }
+serde = { version = "1.0.*", features = ["derive"], optional = true }
 thiserror = "1.0.11"
 unwrap = "1.2.1"
 zeroize = { version = "1.1.0", features = ["zeroize_derive"] }
@@ -27,3 +27,5 @@ zeroize = { version = "1.1.0", features = ["zeroize_derive"] }
 bincode = "1.2.0"
 
 [features]
+default = ["ser"]
+ser = ["serde"]

src/hashs/mod.rs

@@ -18,13 +18,15 @@
 use crate::bases::*;
 use crate::rand::UnspecifiedRandError;
 use ring::{digest, rand};
+#[cfg(feature = "ser")]
 use serde::{Deserialize, Serialize};
 use std::fmt::{Debug, Display, Error, Formatter};
 
 /// A hash wrapper.
 ///
 /// A hash is often provided as string composed of 64 hexadecimal character (0 to 9 then A to F).
-#[derive(Copy, Clone, Deserialize, Eq, Ord, PartialEq, PartialOrd, Hash, Serialize)]
+#[cfg_attr(feature = "ser", derive(Deserialize, Serialize))]
+#[derive(Copy, Clone, Eq, Ord, PartialEq, PartialOrd, Hash)]
 pub struct Hash(pub [u8; 32]);
 
 impl Display for Hash {

src/keys/bin_signable.rs

@@ -85,7 +85,7 @@ mod tests {
     use super::*;
     use bincode;
 
-    #[derive(Deserialize, Serialize)]
+    #[cfg_attr(feature = "ser", derive(Deserialize, Serialize))]
     struct BinSignableTestImpl {
         datas: Vec<u8>,
         issuer: PubKey,

src/keys/ed25519.rs

@@ -27,13 +27,17 @@ use crate::rand::UnspecifiedRandError;
 use crate::seeds::Seed32;
 use base64;
 use ring::signature::{Ed25519KeyPair as RingKeyPair, KeyPair, UnparsedPublicKey, ED25519};
-use serde::de::{Deserializer, Error, SeqAccess, Visitor};
-use serde::ser::{SerializeTuple, Serializer};
-use serde::{Deserialize, Serialize};
+#[cfg(feature = "ser")]
+use serde::{
+    de::{Deserializer, Error, SeqAccess, Visitor},
+    ser::{SerializeTuple, Serializer},
+    Deserialize, Serialize,
+};
 use std::convert::TryFrom;
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::hash::{Hash, Hasher};
+#[cfg(feature = "ser")]
 use std::marker::PhantomData;
 use unwrap::unwrap;
 use zeroize::Zeroize;
@@ -55,6 +59,7 @@ impl Hash for Signature {
     }
 }
 
+#[cfg(feature = "ser")]
 impl Serialize for Signature {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -68,6 +73,7 @@ impl Serialize for Signature {
     }
 }
 
+#[cfg(feature = "ser")]
 impl<'de> Deserialize<'de> for Signature {
     fn deserialize<D>(deserializer: D) -> Result<Signature, D::Error>
     where
@@ -150,7 +156,8 @@ impl Eq for Signature {}
 /// Can be generated with [`KeyPairGenerator`].
 ///
 /// [`KeyPairGenerator`]: struct.KeyPairGenerator.html
-#[derive(Copy, Clone, Deserialize, PartialEq, Eq, Hash, Serialize)]
+#[cfg_attr(feature = "ser", derive(Deserialize, Serialize))]
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct PublicKey {
     datas: [u8; 32],
     len: usize,
@@ -410,9 +417,12 @@ impl KeyPairFromSaltedPasswordGenerator {
 #[cfg(test)]
 mod tests {
     use super::*;
+    #[cfg(feature = "ser")]
     use crate::keys::{KeyPair, Sig, Signator, Signature};
     use crate::seeds::Seed32;
+    #[cfg(feature = "ser")]
     use bincode;
+    #[cfg(feature = "ser")]
     use std::collections::hash_map::DefaultHasher;
 
     #[test]
@@ -533,6 +543,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "ser")]
     fn base64_signature() {
         let signature64 = "1eubHHbuNfilHMM0G2bI30iZzebQ2cQ1PC7uPAw08FG\
                            MMmQCRerlF/3pc4sAcsnexsxBseA/3lY03KlONqJBAg==";
@@ -618,6 +629,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "ser")]
     fn message_sign_verify() {
         let seed = unwrap!(Seed32::from_base58(
             "DNann1Lh55eZMEDXeYt59bzHbA3NJR46DeQYCS2qQdLV"
@@ -689,6 +701,7 @@ Timestamp: 0-E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855
     }
 
     #[test]
+    #[cfg(feature = "ser")]
     fn keypair_generate_sign_and_verify() {
         let keypair = KeyPairFromSaltedPasswordGenerator::with_default_parameters().generate(
             SaltedPassword::new("password".to_owned(), "salt".to_owned()),

src/keys/mod.rs

@@ -48,6 +48,7 @@
 //! `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`
 //! with `=` as padding character.
 
+#[cfg(feature = "ser")]
 pub mod bin_signable;
 pub mod ed25519;
 pub mod text_signable;
@@ -56,6 +57,7 @@ pub use crate::seeds::Seed32;
 
 use crate::bases::b58::ToBase58;
 use crate::bases::BaseConvertionError;
+#[cfg(feature = "ser")]
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 use std::fmt::Debug;
@@ -67,7 +69,8 @@ use std::str::FromStr;
 use thiserror::Error;
 
 /// Cryptographic keys algorithms list
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
+#[cfg_attr(feature = "ser", derive(Deserialize, Serialize))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum KeysAlgo {
     /// Ed25519 algorithm
     Ed25519 = 0,
@@ -146,7 +149,8 @@ pub trait Signature: Clone + Display + Debug + PartialEq + Eq + Hash {
 }
 
 /// Store a cryptographic signature.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[cfg_attr(feature = "ser", derive(Deserialize, Serialize))]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum Sig {
     /// Store a ed25519 Signature
     Ed25519(ed25519::Signature),
@@ -228,7 +232,8 @@ pub trait PublicKey: Clone + Display + Debug + PartialEq + Eq + Hash + ToBase58
 }
 
 /// Store a cryptographic public key.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[cfg_attr(feature = "ser", derive(Deserialize, Serialize))]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum PubKey {
     /// Store a ed25519 public key.
     Ed25519(ed25519::PublicKey),

src/seeds.rs

@@ -19,12 +19,14 @@ use crate::bases::b58::{bytes_to_str_base58, ToBase58};
 use crate::bases::*;
 use crate::rand::UnspecifiedRandError;
 use ring::rand;
+#[cfg(feature = "ser")]
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Debug, Display, Formatter};
 use zeroize::Zeroize;
 
 /// Store a 32 bytes seed used to generate keys.
-#[derive(Clone, Default, Deserialize, PartialEq, Eq, Hash, Serialize, Zeroize)]
+#[cfg_attr(feature = "ser", derive(Deserialize, Serialize))]
+#[derive(Clone, Default, PartialEq, Eq, Hash, Zeroize)]
 #[zeroize(drop)]
 pub struct Seed32([u8; 32]);