Use SignatureBytes and PublicKeyBytes for deposits (#472)

* Replace deposit signatures with SignatureBytes, a struct which lazyly parsers signatures only on demand.

* check byte length when parsing SignatureBytes

* add comment to struct

* distinguish BadSignature and BadSignatureBytes in verify_deposit_signature

* add test for valid signature

* Implements TryInto<Signature> for &SignatureBytes and From<Signature> for &SignatureBytes

* add and use PublicKeyBytes + fix formatting

* fix compiler warning + docs for macro generated structs

* adds tests to ensure correct byte lengths

* small style improvement as suggested by michaelsproul

eth2/utils/bls/src/signature_bytes.rs

@@ -0,0 +1,44 @@
+use ssz::{Decode, DecodeError, Encode};
+
+use super::{Signature, BLS_SIG_BYTE_SIZE};
+
+bytes_struct!(
+    SignatureBytes,
+    Signature,
+    BLS_SIG_BYTE_SIZE,
+    "signature",
+    U96
+);
+
+#[cfg(test)]
+mod tests {
+    use std::convert::TryInto;
+
+    use ssz::ssz_encode;
+
+    use super::super::Keypair;
+    use super::*;
+
+    #[test]
+    pub fn test_valid_signature() {
+        let keypair = Keypair::random();
+        let original = Signature::new(&[42, 42], 0, &keypair.sk);
+
+        let bytes = ssz_encode(&original);
+        let signature_bytes = SignatureBytes::from_bytes(&bytes).unwrap();
+        let signature: Result<Signature, _> = (&signature_bytes).try_into();
+        assert!(signature.is_ok());
+        assert_eq!(original, signature.unwrap());
+    }
+
+    #[test]
+    pub fn test_invalid_signature() {
+        let mut signature_bytes = [0; BLS_SIG_BYTE_SIZE];
+        signature_bytes[0] = 255; //a_flag1 == b_flag1 == c_flag1 == 1 and x1 = 0 shouldn't be allowed
+        let signature_bytes = SignatureBytes::from_bytes(&signature_bytes[..]);
+        assert!(signature_bytes.is_ok());
+
+        let signature: Result<Signature, _> = signature_bytes.as_ref().unwrap().try_into();
+        assert!(signature.is_err());
+    }
+}