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,235 @@
+// 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::Error as SerdeError;
+use serde::{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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        PublicKey::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}
+
+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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        SecretKey::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}
+
+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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        Signature::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}
+
+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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        PublicKeyDouble::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}
+
+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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        SignatureDouble::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}
+
+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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        PublicKeyVarGen::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}
+
+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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        SecretKeyVarGen::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}
+
+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 decoded =
+            bs58::decode(&s).into_vec().map_err(SerdeError::custom)?;
+        let decoded_len = decoded.len();
+        let byte_length_str = format!("{}", Self::SIZE);
+        let bytes: [u8; Self::SIZE] = decoded.try_into().map_err(|_| {
+            SerdeError::invalid_length(decoded_len, &byte_length_str.as_str())
+        })?;
+        SignatureVarGen::from_bytes(&bytes)
+            .map_err(|err| SerdeError::custom(format!("{err:?}")))
+    }
+}