Remove tree hashing from ssz crate

eth2/utils/ssz/src/impl_tree_hash.rs

@@ -1,85 +0,0 @@
-use super::ethereum_types::{Address, H256};
-use super::{merkle_hash, ssz_encode, TreeHash};
-use hashing::hash;
-
-impl TreeHash for u8 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for u16 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for u32 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for u64 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for usize {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for bool {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for Address {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for H256 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for [u8] {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        if self.len() > 32 {
-            return hash(&self);
-        }
-        self.to_vec()
-    }
-}
-
-impl<T> TreeHash for Vec<T>
-where
-    T: TreeHash,
-{
-    /// Returns the merkle_hash of a list of hash_tree_root values created
-    /// from the given list.
-    /// Note: A byte vector, Vec<u8>, must be converted to a slice (as_slice())
-    ///       to be handled properly (i.e. hashed) as byte array.
-    fn hash_tree_root(&self) -> Vec<u8> {
-        let mut tree_hashes = self.iter().map(|x| x.hash_tree_root()).collect();
-        merkle_hash(&mut tree_hashes)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_impl_tree_hash_vec() {
-        let result = vec![1u32, 2, 3, 4, 5, 6, 7].hash_tree_root();
-        assert_eq!(result.len(), 32);
-    }
-}

eth2/utils/ssz/src/lib.rs

@@ -12,17 +12,12 @@ extern crate ethereum_types;
 
 pub mod decode;
 pub mod encode;
-mod signed_root;
-pub mod tree_hash;
 
 mod impl_decode;
 mod impl_encode;
-mod impl_tree_hash;
 
 pub use crate::decode::{decode, decode_ssz_list, Decodable, DecodeError};
 pub use crate::encode::{Encodable, SszStream};
-pub use crate::signed_root::SignedRoot;
-pub use crate::tree_hash::{merkle_hash, TreeHash};
 
 pub use hashing::hash;
 

eth2/utils/ssz/src/signed_root.rs

@@ -1,5 +0,0 @@
-use crate::TreeHash;
-
-pub trait SignedRoot: TreeHash {
-    fn signed_root(&self) -> Vec<u8>;
-}

eth2/utils/ssz/src/tree_hash.rs

@@ -1,107 +0,0 @@
-use hashing::hash;
-
-const BYTES_PER_CHUNK: usize = 32;
-const HASHSIZE: usize = 32;
-
-pub trait TreeHash {
-    fn hash_tree_root(&self) -> Vec<u8>;
-}
-
-/// Returns a 32 byte hash of 'list' - a vector of byte vectors.
-/// Note that this will consume 'list'.
-pub fn merkle_hash(list: &mut Vec<Vec<u8>>) -> Vec<u8> {
-    // flatten list
-    let mut chunkz = list_to_blob(list);
-
-    // get data_len as bytes. It will hashed will the merkle root
-    let mut datalen = list.len().to_le_bytes().to_vec();
-    zpad(&mut datalen, 32);
-
-    // merklelize
-    while chunkz.len() > HASHSIZE {
-        let mut new_chunkz: Vec<u8> = Vec::new();
-
-        for two_chunks in chunkz.chunks(BYTES_PER_CHUNK * 2) {
-            // Hash two chuncks together
-            new_chunkz.append(&mut hash(two_chunks));
-        }
-
-        chunkz = new_chunkz;
-    }
-
-    chunkz.append(&mut datalen);
-    hash(&chunkz)
-}
-
-fn list_to_blob(list: &mut Vec<Vec<u8>>) -> Vec<u8> {
-    // pack - fit as many many items per chunk as we can and then
-    // right pad to BYTES_PER_CHUNCK
-    let (items_per_chunk, chunk_count) = if list.is_empty() {
-        (1, 1)
-    } else {
-        let items_per_chunk = BYTES_PER_CHUNK / list[0].len();
-        let chunk_count = list.len() / items_per_chunk;
-        (items_per_chunk, chunk_count)
-    };
-
-    let mut chunkz = Vec::new();
-    if list.is_empty() {
-        // handle and empty list
-        chunkz.append(&mut vec![0; BYTES_PER_CHUNK * 2]);
-    } else if list[0].len() <= BYTES_PER_CHUNK {
-        // just create a blob here; we'll divide into
-        // chunked slices when we merklize
-        let mut chunk = Vec::with_capacity(BYTES_PER_CHUNK);
-        let mut item_count_in_chunk = 0;
-        chunkz.reserve(chunk_count * BYTES_PER_CHUNK);
-        for item in list.iter_mut() {
-            item_count_in_chunk += 1;
-            chunk.append(item);
-
-            // completed chunk?
-            if item_count_in_chunk == items_per_chunk {
-                zpad(&mut chunk, BYTES_PER_CHUNK);
-                chunkz.append(&mut chunk);
-                item_count_in_chunk = 0;
-            }
-        }
-
-        // left-over uncompleted chunk?
-        if item_count_in_chunk != 0 {
-            zpad(&mut chunk, BYTES_PER_CHUNK);
-            chunkz.append(&mut chunk);
-        }
-    }
-
-    // extend the number of chunks to a power of two if necessary
-    if !chunk_count.is_power_of_two() {
-        let zero_chunks_count = chunk_count.next_power_of_two() - chunk_count;
-        chunkz.append(&mut vec![0; zero_chunks_count * BYTES_PER_CHUNK]);
-    }
-
-    chunkz
-}
-
-/// right pads with zeros making 'bytes' 'size' in length
-fn zpad(bytes: &mut Vec<u8>, size: usize) {
-    if bytes.len() < size {
-        bytes.resize(size, 0);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_merkle_hash() {
-        let data1 = vec![1; 32];
-        let data2 = vec![2; 32];
-        let data3 = vec![3; 32];
-        let mut list = vec![data1, data2, data3];
-        let result = merkle_hash(&mut list);
-
-        //note: should test againt a known test hash value
-        assert_eq!(HASHSIZE, result.len());
-    }
-}