Merge ssz little endian branch

eth2/utils/bls/src/aggregate_signature.rs

@@ -173,7 +173,7 @@ impl TreeHash for AggregateSignature {
 mod tests {
     use super::super::{Keypair, Signature};
     use super::*;
-    use ssz::ssz_encode;
+    use ssz::{decode, ssz_encode};
 
     #[test]
     pub fn test_ssz_round_trip() {
@@ -183,7 +183,7 @@ mod tests {
         original.add(&Signature::new(&[42, 42], 0, &keypair.sk));
 
         let bytes = ssz_encode(&original);
-        let (decoded, _) = AggregateSignature::ssz_decode(&bytes, 0).unwrap();
+        let decoded = decode::<AggregateSignature>(&bytes).unwrap();
 
         assert_eq!(original, decoded);
     }

eth2/utils/bls/src/lib.rs

@@ -6,7 +6,6 @@ mod aggregate_signature;
 mod keypair;
 mod public_key;
 mod secret_key;
-mod serde_vistors;
 mod signature;
 
 pub use crate::aggregate_public_key::AggregatePublicKey;

eth2/utils/bls/src/public_key.rs

@@ -4,7 +4,8 @@ use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::{encode as hex_encode, PrefixedHexVisitor};
 use ssz::{
-    decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
+    decode, decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream,
+    TreeHash,
 };
 use std::default;
 use std::hash::{Hash, Hasher};
@@ -90,9 +91,9 @@ impl<'de> Deserialize<'de> for PublicKey {
         D: Deserializer<'de>,
     {
         let bytes = deserializer.deserialize_str(PrefixedHexVisitor)?;
-        let obj = PublicKey::from_bytes(&bytes[..])
+        let pubkey = PublicKey::from_bytes(&bytes[..])
             .map_err(|e| serde::de::Error::custom(format!("invalid pubkey ({:?})", e)))?;
-        Ok(obj)
+        Ok(pubkey)
     }
 }
 

eth2/utils/bls/src/secret_key.rs

@@ -1,9 +1,11 @@
-use super::serde_vistors::HexVisitor;
 use bls_aggregates::{DecodeError as BlsDecodeError, SecretKey as RawSecretKey};
 use hex::encode as hex_encode;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
-use ssz::{decode_ssz_list, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use serde_hex::HexVisitor;
+use ssz::{
+    decode, decode_ssz_list, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
+};
 
 /// A single BLS signature.
 ///
@@ -59,9 +61,9 @@ impl<'de> Deserialize<'de> for SecretKey {
         D: Deserializer<'de>,
     {
         let bytes = deserializer.deserialize_str(HexVisitor)?;
-        let (pubkey, _) = <_>::ssz_decode(&bytes[..], 0)
+        let secret_key = decode::<SecretKey>(&bytes[..])
             .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?;
-        Ok(pubkey)
+        Ok(secret_key)
     }
 }
 

eth2/utils/bls/src/serde_vistors.rs

@@ -1,21 +0,0 @@
-use hex;
-use serde::de::{self, Visitor};
-use std::fmt;
-
-pub struct HexVisitor;
-
-impl<'de> Visitor<'de> for HexVisitor {
-    type Value = Vec<u8>;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a hex string (irrelevant of prefix)")
-    }
-
-    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(hex::decode(value.trim_start_matches("0x"))
-            .map_err(|e| de::Error::custom(format!("invalid hex ({:?})", e)))?)
-    }
-}

eth2/utils/bls/src/signature.rs

@@ -1,11 +1,12 @@
-use super::serde_vistors::HexVisitor;
 use super::{PublicKey, SecretKey, BLS_SIG_BYTE_SIZE};
 use bls_aggregates::Signature as RawSignature;
 use hex::encode as hex_encode;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
+use serde_hex::HexVisitor;
 use ssz::{
-    decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
+    decode, decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream,
+    TreeHash,
 };
 
 /// A single BLS signature.
@@ -136,7 +137,7 @@ impl<'de> Deserialize<'de> for Signature {
     where
         D: Deserializer<'de>,
     {
-        let bytes: Vec<u8> = deserializer.deserialize_str(HexVisitor)?;
+        let bytes = deserializer.deserialize_str(HexVisitor)?;
         let signature = Signature::from_bytes(&bytes[..])
             .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?;
         Ok(signature)
@@ -156,7 +157,7 @@ mod tests {
         let original = Signature::new(&[42, 42], 0, &keypair.sk);
 
         let bytes = ssz_encode(&original);
-        let (decoded, _) = Signature::ssz_decode(&bytes, 0).unwrap();
+        let decoded = decode::<Signature>(&bytes).unwrap();
 
         assert_eq!(original, decoded);
     }