Resolved issue with enum deserialization.

crates/node/src/serde_blocktree/de.rs

@@ -1,13 +1,13 @@
 use std::convert::TryFrom;
 use std::str;
 use std::io::Read;
-use super::error::{Error, Result, MapError};
+use super::error::{Error, Result};
 use serde::de::{
     self,
     Visitor,
-    DeserializeSeed
+    DeserializeSeed,
+    IntoDeserializer
 };
-use std::marker::PhantomData;
 
 pub struct Deserializer<'de, T: Read + ?Sized> {
     input: &'de mut T,
@@ -237,12 +237,12 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
         visitor.visit_enum(self)
     }
 
-    fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+    fn deserialize_identifier<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
+        Err(Error::NotSupported("Deserializer::deserialize_identifier"))
     }
 
-    fn deserialize_ignored_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+    fn deserialize_ignored_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
+        Err(Error::NotSupported("Deserializer::deserialize_ignored_any"))
     }
 
     fn is_human_readable(&self) -> bool {
@@ -312,12 +312,15 @@ impl<'a, 'de, T: Read> de::EnumAccess<'de> for &mut Deserializer<'de, T> {
     type Variant = Self;
     
     fn variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<(S::Value, Self::Variant)> {
-        let value = seed.deserialize(&mut *self)?;
+        let int = self.read_u16()?;
+        let index: u32 = try_from(int)?;
+        let value = seed.deserialize(index.into_deserializer())?;
         Ok((value, self))
     }
 }
 
 mod test {
+    #[allow(unused_imports)]
     use serde::Deserialize;
     #[allow(unused_imports)]
     use super::{Result, Deserializer};
@@ -335,7 +338,7 @@ mod test {
     fn deserialize_enum() -> Result<()> {
         #[derive(Debug, PartialEq, Deserialize)]
         enum Emotions { Anguish, Catharsis }
-        let vec: Vec<u8> = vec![0x01];
+        let vec: Vec<u8> = vec![0x01, 0x00];
         let mut slice = vec.as_slice();
         let mut de = Deserializer::new(&mut slice);
         let value = Deserialize::deserialize(&mut de)?;

crates/node/src/serde_blocktree/error.rs

@@ -12,6 +12,7 @@ pub enum Error {
     SequenceTooLong(usize),
     TooManyVariants(u32),
     TypeConversion,
+    NotSupported(&'static str),
 }
 
 impl std::error::Error for Error {}
@@ -30,6 +31,8 @@ impl Display for Error {
                 format_args!("too many variants to be serialized, the limit is 2**16: {}", length)
             ),
             Error::TypeConversion => formatter.write_str("type conversion failed"),
+            Error::NotSupported(message) => formatter.write_fmt(format_args!(
+                "Operation is not supported: {}", message))
         }
     }
 }