Use smallvec for tree hash packed encoding

consensus/tree_hash/src/impls.rs

@@ -1,5 +1,6 @@
 use super::*;
 use ethereum_types::{H160, H256, U128, U256};
+use smallvec::{smallvec, ToSmallVec};
 
 fn int_to_hash256(int: u64) -> Hash256 {
     let mut bytes = [0; HASHSIZE];
@@ -14,8 +15,8 @@ macro_rules! impl_for_bitsize {
                 TreeHashType::Basic
             }
 
-            fn tree_hash_packed_encoding(&self) -> Vec<u8> {
-                self.to_le_bytes().to_vec()
+            fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+                self.to_le_bytes().to_smallvec()
             }
 
             fn tree_hash_packing_factor() -> usize {
@@ -41,7 +42,7 @@ impl TreeHash for bool {
         TreeHashType::Basic
     }
 
-    fn tree_hash_packed_encoding(&self) -> Vec<u8> {
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
         (*self as u8).tree_hash_packed_encoding()
     }
 
@@ -62,7 +63,7 @@ macro_rules! impl_for_lt_32byte_u8_array {
                 TreeHashType::Vector
             }
 
-            fn tree_hash_packed_encoding(&self) -> Vec<u8> {
+            fn tree_hash_packed_encoding(&self) -> PackedEncoding {
                 unreachable!("bytesN should never be packed.")
             }
 
@@ -87,8 +88,8 @@ impl TreeHash for U128 {
         TreeHashType::Basic
     }
 
-    fn tree_hash_packed_encoding(&self) -> Vec<u8> {
-        let mut result = vec![0; 16];
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+        let mut result = smallvec![0; 16];
         self.to_little_endian(&mut result);
         result
     }
@@ -109,8 +110,8 @@ impl TreeHash for U256 {
         TreeHashType::Basic
     }
 
-    fn tree_hash_packed_encoding(&self) -> Vec<u8> {
-        let mut result = vec![0; 32];
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+        let mut result = smallvec![0; 32];
         self.to_little_endian(&mut result);
         result
     }
@@ -131,8 +132,8 @@ impl TreeHash for H160 {
         TreeHashType::Vector
     }
 
-    fn tree_hash_packed_encoding(&self) -> Vec<u8> {
-        let mut result = vec![0; 32];
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+        let mut result = smallvec![0; 32];
         result[0..20].copy_from_slice(self.as_bytes());
         result
     }
@@ -153,8 +154,8 @@ impl TreeHash for H256 {
         TreeHashType::Vector
     }
 
-    fn tree_hash_packed_encoding(&self) -> Vec<u8> {
-        self.as_bytes().to_vec()
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+        self.as_bytes().to_smallvec()
     }
 
     fn tree_hash_packing_factor() -> usize {

consensus/tree_hash/src/lib.rs

@@ -8,6 +8,7 @@ pub use merkleize_padded::merkleize_padded;
 pub use merkleize_standard::merkleize_standard;
 
 use eth2_hashing::{hash_fixed, ZERO_HASHES, ZERO_HASHES_MAX_INDEX};
+use smallvec::SmallVec;
 
 pub const BYTES_PER_CHUNK: usize = 32;
 pub const HASHSIZE: usize = 32;
@@ -15,6 +16,7 @@ pub const MERKLE_HASH_CHUNK: usize = 2 * BYTES_PER_CHUNK;
 pub const MAX_UNION_SELECTOR: u8 = 127;
 
 pub type Hash256 = ethereum_types::H256;
+pub type PackedEncoding = SmallVec<[u8; BYTES_PER_CHUNK]>;
 
 /// Convenience method for `MerkleHasher` which also provides some fast-paths for small trees.
 ///
@@ -109,7 +111,7 @@ pub enum TreeHashType {
 pub trait TreeHash {
     fn tree_hash_type() -> TreeHashType;
 
-    fn tree_hash_packed_encoding(&self) -> Vec<u8>;
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding;
 
     fn tree_hash_packing_factor() -> usize;
 
@@ -125,7 +127,7 @@ where
         T::tree_hash_type()
     }
 
-    fn tree_hash_packed_encoding(&self) -> Vec<u8> {
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
         T::tree_hash_packed_encoding(*self)
     }
 
@@ -138,52 +140,6 @@ where
     }
 }
 
-#[macro_export]
-macro_rules! tree_hash_ssz_encoding_as_vector {
-    ($type: ident) => {
-        impl tree_hash::TreeHash for $type {
-            fn tree_hash_type() -> tree_hash::TreeHashType {
-                tree_hash::TreeHashType::Vector
-            }
-
-            fn tree_hash_packed_encoding(&self) -> Vec<u8> {
-                unreachable!("Vector should never be packed.")
-            }
-
-            fn tree_hash_packing_factor() -> usize {
-                unreachable!("Vector should never be packed.")
-            }
-
-            fn tree_hash_root(&self) -> Vec<u8> {
-                tree_hash::merkle_root(&ssz::ssz_encode(self))
-            }
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! tree_hash_ssz_encoding_as_list {
-    ($type: ident) => {
-        impl tree_hash::TreeHash for $type {
-            fn tree_hash_type() -> tree_hash::TreeHashType {
-                tree_hash::TreeHashType::List
-            }
-
-            fn tree_hash_packed_encoding(&self) -> Vec<u8> {
-                unreachable!("List should never be packed.")
-            }
-
-            fn tree_hash_packing_factor() -> usize {
-                unreachable!("List should never be packed.")
-            }
-
-            fn tree_hash_root(&self) -> Vec<u8> {
-                ssz::ssz_encode(self).tree_hash_root()
-            }
-        }
-    };
-}
-
 #[cfg(test)]
 mod test {
     use super::*;