Merge pull request #212 from anoma/fix/delta-witness-serde-deserialize

Fix DeltaWitness serde Deserialize to match Serialize

Author: XuyangSong

arm/src/delta_proof.rs

@@ -209,25 +209,59 @@ impl<'de> Deserialize<'de> for DeltaWitness {
     where
         D: serde::Deserializer<'de>,
     {
-        let bytes = <[u8; 32]>::deserialize(deserializer)?;
+        let bytes: Vec<u8> = Vec::deserialize(deserializer)?;
+        if bytes.len() != 32 {
+            return Err(serde::de::Error::custom(
+                "Invalid byte length for DeltaWitness",
+            ));
+        }
         DeltaWitness::from_bytes(&bytes).map_err(|e| {
             serde::de::Error::custom(format!("Failed to deserialize DeltaWitness: {:?}", e))
         })
     }
 }
 
-#[test]
-fn test_delta_proof() {
+#[cfg(test)]
+mod tests {
+    use super::*;
     use k256::elliptic_curve::rand_core::OsRng;
 
-    let mut rng = OsRng;
-    let signing_key = SigningKey::random(&mut rng);
-    let verifying_key = VerifyingKey::from(&signing_key);
+    #[test]
+    fn test_delta_proof() {
+        let mut rng = OsRng;
+        let signing_key = SigningKey::random(&mut rng);
+        let verifying_key = VerifyingKey::from(&signing_key);
+
+        let message = b"Hello, world!";
+        let witness = DeltaWitness { signing_key };
+        let proof = DeltaProof::prove(message, &witness).unwrap();
+        let instance = DeltaInstance { verifying_key };
 
-    let message = b"Hello, world!";
-    let witness = DeltaWitness { signing_key };
-    let proof = DeltaProof::prove(message, &witness).unwrap();
-    let instance = DeltaInstance { verifying_key };
+        DeltaProof::verify(message, &proof, instance).unwrap();
+    }
 
-    DeltaProof::verify(message, &proof, instance).unwrap();
+    /// DeltaProof: serialize then deserialize via bincode must round-trip.
+    #[test]
+    fn delta_proof_bincode_roundtrip() {
+        let mut rng = OsRng;
+        let signing_key = SigningKey::random(&mut rng);
+        let witness = DeltaWitness { signing_key };
+        let proof = DeltaProof::prove(b"roundtrip", &witness).unwrap();
+
+        let encoded = bincode::serialize(&proof).unwrap();
+        let decoded: DeltaProof = bincode::deserialize(&encoded).unwrap();
+        assert_eq!(proof, decoded);
+    }
+
+    /// DeltaWitness: serialize then deserialize via bincode must round-trip.
+    #[test]
+    fn delta_witness_bincode_roundtrip() {
+        let mut rng = OsRng;
+        let signing_key = SigningKey::random(&mut rng);
+        let witness = DeltaWitness { signing_key };
+
+        let encoded = bincode::serialize(&witness).unwrap();
+        let decoded: DeltaWitness = bincode::deserialize(&encoded).unwrap();
+        assert_eq!(witness, decoded);
+    }
 }