Added serde support

.github/workflows/dusk_ci.yaml

@@ -8,7 +8,7 @@ jobs:
     uses: dusk-network/.github/.github/workflows/code-analysis.yml@main
     with:
       clippy_default: false
-      clippy_args: --features=rkyv/size_32,zk
+      clippy_args: --features=rkyv/size_32,zk,serde
 
   dusk_analyzer:
     name: Dusk Analyzer
@@ -26,7 +26,7 @@ jobs:
     name: Nightly tests
     uses: dusk-network/.github/.github/workflows/run-tests.yml@main
     with:
-      test_flags: --features=zk,alloc
+      test_flags: --features=zk,alloc,serde
 
   test_nightly_multisig_compiles:
     name: Nightly multisig tests compile

Cargo.toml

@@ -25,6 +25,9 @@ zeroize = { version = "1", default-features = false, features = ["derive"] }
 rkyv = { version = "0.7", optional = true, default-features = false }
 bytecheck = { version = "0.6", optional = true, default-features = false }
 dusk-plonk = { version = "0.20", default-features = false, features = ["alloc"], optional = true }
+serde = { version = "1.0", optional = true }
+bs58 = { version = "0.4" , optional = true }
+serde_json = { version = "1.0", optional = true }
 
 [dev-dependencies]
 rkyv = { version = "0.7", default-features = false, features = ["size_32"] }
@@ -62,6 +65,11 @@ rkyv-impl = [
     "rkyv",
     "bytecheck",
 ]
+serde = [
+    "dep:serde",
+    "bs58",
+    "serde_json"
+]
 
 [[test]]
 name = "gadgets"

src/lib.rs

@@ -14,6 +14,9 @@ mod signatures;
 #[cfg(feature = "zk")]
 pub mod gadgets;
 
+#[cfg(feature = "serde")]
+mod serde_support;
+
 pub use error::Error;
 pub use keys::public::PublicKey;
 pub use keys::secret::SecretKey;

src/serde_support.rs

@@ -0,0 +1,266 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) DUSK NETWORK. All rights reserved.
+
+extern crate alloc;
+
+use alloc::format;
+use alloc::string::String;
+
+use dusk_bytes::Serializable;
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::{
+    PublicKey, PublicKeyDouble, PublicKeyVarGen, SecretKey, SecretKeyVarGen,
+    Signature, SignatureDouble, SignatureVarGen,
+};
+
+impl Serialize for PublicKey {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for PublicKey {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            PublicKey::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize PublicKey: invalid byte length",
+            ))
+        }
+    }
+}
+
+impl Serialize for SecretKey {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for SecretKey {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            SecretKey::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize SecretKey: invalid byte length",
+            ))
+        }
+    }
+}
+
+impl Serialize for Signature {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for Signature {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            Signature::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize Signature: invalid byte length",
+            ))
+        }
+    }
+}
+
+impl Serialize for PublicKeyDouble {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for PublicKeyDouble {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            PublicKeyDouble::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize PublicKeyDouble: invalid byte length",
+            ))
+        }
+    }
+}
+
+impl Serialize for SignatureDouble {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for SignatureDouble {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            SignatureDouble::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize SignatureDouble: invalid byte length",
+            ))
+        }
+    }
+}
+
+impl Serialize for PublicKeyVarGen {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for PublicKeyVarGen {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            PublicKeyVarGen::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize PublicKeyVarGen: invalid byte length",
+            ))
+        }
+    }
+}
+
+impl Serialize for SecretKeyVarGen {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for SecretKeyVarGen {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            SecretKeyVarGen::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize SecretKeyVarGen: invalid byte length",
+            ))
+        }
+    }
+}
+
+impl Serialize for SignatureVarGen {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let s = bs58::encode(self.to_bytes()).into_string();
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for SignatureVarGen {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        let mut bytes = [0; Self::SIZE];
+        let bytes_written = bs58::decode(&s)
+            .into(&mut bytes)
+            .map_err(de::Error::custom)?;
+        if bytes_written == Self::SIZE {
+            SignatureVarGen::from_bytes(&bytes).map_err(|err| {
+                serde::de::Error::custom(format!("{:?}", err))
+            })
+        } else {
+            Err(de::Error::custom(
+                "Failed to deserialize SignatureVarGen: invalid byte length",
+            ))
+        }
+    }
+}