Add serde feature

.gitignore

@@ -1,3 +1,4 @@
 /.idea/
+/.vscode/
 /target/
 Cargo.lock

Cargo.toml

@@ -2,7 +2,7 @@
 name = "everscale-crypto"
 description = "Cryptography primitives for Everscale"
 repository = "https://github.com/broxus/everscale-crypto"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 include = ["src/**/*.rs", "README.md", "LICENSE"]
 license-file = "./LICENSE"
@@ -14,6 +14,8 @@ hex = "0.4.3"
 rand = "0.8.4"
 sha2 = "0.10"
 tl-proto = { version = "0.4.0", features = ["derive"], optional = true }
+serde = { version = "1", optional = true }
 
 [features]
 default = ["tl-proto"]
+serde = ["dep:serde"]

src/ed25519/mod.rs

@@ -187,7 +187,7 @@ impl PartialEq for PublicKey {
 
 impl Eq for PublicKey {}
 
-impl std::fmt::Debug for PublicKey {
+impl std::fmt::Display for PublicKey {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let mut output = [0u8; 64];
         hex::encode_to_slice(self.compressed.as_bytes(), &mut output).ok();
@@ -198,6 +198,66 @@ impl std::fmt::Debug for PublicKey {
     }
 }
 
+impl std::fmt::Debug for PublicKey {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for PublicKey {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if serializer.is_human_readable() {
+            serializer.collect_str(self)
+        } else {
+            self.as_bytes().serialize(serializer)
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PublicKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use serde::de::{Error, Visitor};
+
+        struct BytesVisitor;
+
+        impl<'de> Visitor<'de> for BytesVisitor {
+            type Value = [u8; 32];
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("hex-encoded public key")
+            }
+
+            fn visit_str<E: Error>(self, value: &str) -> Result<Self::Value, E> {
+                let mut result = [0; 32];
+                match hex::decode_to_slice(value, &mut result) {
+                    Ok(()) => Ok(result),
+                    Err(_) => Err(Error::invalid_value(
+                        serde::de::Unexpected::Str(value),
+                        &self,
+                    )),
+                }
+            }
+        }
+
+        let bytes = if deserializer.is_human_readable() {
+            deserializer.deserialize_str(BytesVisitor)
+        } else {
+            <[u8; 32]>::deserialize(deserializer)
+        }?;
+
+        Self::from_bytes(bytes).ok_or_else(|| Error::custom("invalid public key"))
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct ExpandedSecretKey {
     key: Scalar,