get spec tests working and fix json serialization

crypto/kzg/src/kzg_proof.rs

@@ -1,15 +1,16 @@
-use serde::{Deserialize, Serialize};
-use serde_big_array::BigArray;
+use serde::de::{Deserialize, Deserializer};
+use serde::ser::{Serialize, Serializer};
 use ssz_derive::{Decode, Encode};
 use std::fmt;
+use std::fmt::Debug;
+use std::str::FromStr;
 use tree_hash::{PackedEncoding, TreeHash};
 
 const KZG_PROOF_BYTES_LEN: usize = 48;
 
-#[derive(Debug, PartialEq, Hash, Clone, Copy, Encode, Decode, Serialize, Deserialize)]
-#[serde(transparent)]
+#[derive(PartialEq, Hash, Clone, Copy, Encode, Decode)]
 #[ssz(struct_behaviour = "transparent")]
-pub struct KzgProof(#[serde(with = "BigArray")] pub [u8; KZG_PROOF_BYTES_LEN]);
+pub struct KzgProof(pub [u8; KZG_PROOF_BYTES_LEN]);
 
 impl fmt::Display for KzgProof {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -19,7 +20,7 @@ impl fmt::Display for KzgProof {
 
 impl Default for KzgProof {
     fn default() -> Self {
-        KzgProof([0; 48])
+        KzgProof([0; KZG_PROOF_BYTES_LEN])
     }
 }
 
@@ -52,3 +53,68 @@ impl TreeHash for KzgProof {
         self.0.tree_hash_root()
     }
 }
+
+impl Serialize for KzgProof {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl<'de> Deserialize<'de> for KzgProof {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        pub struct StringVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for StringVisitor {
+            type Value = String;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a hex string with 0x prefix")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(value.to_string())
+            }
+        }
+
+        let string = deserializer.deserialize_str(StringVisitor)?;
+        <Self as std::str::FromStr>::from_str(&string).map_err(serde::de::Error::custom)
+    }
+}
+
+impl FromStr for KzgProof {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Some(stripped) = s.strip_prefix("0x") {
+            let bytes = hex::decode(stripped).map_err(|e| e.to_string())?;
+            if bytes.len() == KZG_PROOF_BYTES_LEN {
+                let mut kzg_proof_bytes = [0; KZG_PROOF_BYTES_LEN];
+                kzg_proof_bytes[..].copy_from_slice(&bytes);
+                Ok(Self(kzg_proof_bytes))
+            } else {
+                Err(format!(
+                    "InvalidByteLength: got {}, expected {}",
+                    bytes.len(),
+                    KZG_PROOF_BYTES_LEN
+                ))
+            }
+        } else {
+            Err("must start with 0x".to_string())
+        }
+    }
+}
+
+impl Debug for KzgProof {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", eth2_serde_utils::hex::encode(&self.0))
+    }
+}