comits: fix ReservedBytes serde deserialization

Author: dr-orlovsky

commit_verify/src/lib.rs

@@ -118,6 +118,11 @@ impl<const LEN: usize, const VAL: u8> From<[u8; LEN]> for ReservedBytes<LEN, VAL
     }
 }
 
+impl<const LEN: usize, const VAL: u8> ReservedBytes<LEN, VAL> {
+    /// Constant constructor.
+    pub const fn new() -> Self { Self([VAL; LEN]) }
+}
+
 mod _reserved {
     use strict_encoding::{DecodeError, ReadTuple, StrictDecode, TypedRead};
 
@@ -148,44 +153,41 @@ mod _reserved {
     mod _serde {
         use std::fmt;
 
-        use serde::de::Visitor;
-        use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+        use serde::de::{Error, Visitor};
+        use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
         use super::*;
 
         impl<const LEN: usize, const VAL: u8> Serialize for ReservedBytes<LEN, VAL> {
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
             where S: Serializer {
-                // Doing nothing
-                serializer.serialize_unit()
+                serializer.serialize_bytes(self.0.as_ref())
             }
         }
 
         impl<'de, const LEN: usize, const VAL: u8> Deserialize<'de> for ReservedBytes<LEN, VAL> {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where D: Deserializer<'de> {
                 #[derive(Default)]
-                pub struct UntaggedUnitVisitor;
+                pub struct UntaggedUnitVisitor<const L: usize, const V: u8>;
 
-                impl Visitor<'_> for UntaggedUnitVisitor {
-                    type Value = ();
+                impl<const L: usize, const V: u8> Visitor<'_> for UntaggedUnitVisitor<L, V> {
+                    type Value = ReservedBytes<L, V>;
 
                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                         write!(formatter, "reserved unit")
                     }
 
-                    fn visit_none<E>(self) -> Result<(), E>
-                    where E: de::Error {
-                        Ok(())
-                    }
-
-                    fn visit_unit<E>(self) -> Result<(), E>
-                    where E: de::Error {
-                        Ok(())
+                    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                    where E: Error {
+                        if v != [V; L] {
+                            return Err(Error::custom("invalid reserved value"));
+                        }
+                        Ok(ReservedBytes::<L, V>::new())
                     }
                 }
 
-                deserializer.deserialize_unit(UntaggedUnitVisitor)?;
+                deserializer.deserialize_unit(UntaggedUnitVisitor::<LEN, VAL>)?;
                 Ok(default!())
             }
         }