Create cached_tree_hash crate.

eth2/utils/tree_hash/src/lib.rs

@@ -1,14 +1,10 @@
-pub mod cached_tree_hash;
-pub mod signed_root;
-pub mod standard_tree_hash;
+use hashing::hash;
+
+pub mod impls;
 
 pub const BYTES_PER_CHUNK: usize = 32;
 pub const HASHSIZE: usize = 32;
-pub const MERKLE_HASH_CHUNCK: usize = 2 * BYTES_PER_CHUNK;
-
-pub use cached_tree_hash::{BTreeOverlay, CachedTreeHash, Error, TreeHashCache};
-pub use signed_root::SignedRoot;
-pub use standard_tree_hash::{merkle_root, TreeHash};
+pub const MERKLE_HASH_CHUNK: usize = 2 * BYTES_PER_CHUNK;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum TreeHashType {
@@ -18,6 +14,78 @@ pub enum TreeHashType {
     Container,
 }
 
+pub trait TreeHash {
+    fn tree_hash_type() -> TreeHashType;
+
+    fn tree_hash_packed_encoding(&self) -> Vec<u8>;
+
+    fn tree_hash_packing_factor() -> usize;
+
+    fn tree_hash_root(&self) -> Vec<u8>;
+}
+
+pub trait SignedRoot: TreeHash {
+    fn signed_root(&self) -> Vec<u8>;
+}
+
+pub fn merkle_root(bytes: &[u8]) -> Vec<u8> {
+    // TODO: replace this with a more memory efficient method.
+    efficient_merkleize(&bytes)[0..32].to_vec()
+}
+
+pub fn efficient_merkleize(bytes: &[u8]) -> Vec<u8> {
+    // If the bytes are just one chunk (or less than one chunk) just return them.
+    if bytes.len() <= HASHSIZE {
+        let mut o = bytes.to_vec();
+        o.resize(HASHSIZE, 0);
+        return o;
+    }
+
+    let leaves = num_sanitized_leaves(bytes.len());
+    let nodes = num_nodes(leaves);
+    let internal_nodes = nodes - leaves;
+
+    let num_bytes = std::cmp::max(internal_nodes, 1) * HASHSIZE + bytes.len();
+
+    let mut o: Vec<u8> = vec![0; internal_nodes * HASHSIZE];
+
+    o.append(&mut bytes.to_vec());
+
+    assert_eq!(o.len(), num_bytes);
+
+    let empty_chunk_hash = hash(&[0; MERKLE_HASH_CHUNK]);
+
+    let mut i = nodes * HASHSIZE;
+    let mut j = internal_nodes * HASHSIZE;
+
+    while i >= MERKLE_HASH_CHUNK {
+        i -= MERKLE_HASH_CHUNK;
+
+        j -= HASHSIZE;
+        let hash = match o.get(i..i + MERKLE_HASH_CHUNK) {
+            // All bytes are available, hash as ususal.
+            Some(slice) => hash(slice),
+            // Unable to get all the bytes.
+            None => {
+                match o.get(i..) {
+                    // Able to get some of the bytes, pad them out.
+                    Some(slice) => {
+                        let mut bytes = slice.to_vec();
+                        bytes.resize(MERKLE_HASH_CHUNK, 0);
+                        hash(&bytes)
+                    }
+                    // Unable to get any bytes, use the empty-chunk hash.
+                    None => empty_chunk_hash.clone(),
+                }
+            }
+        };
+
+        o[j..j + HASHSIZE].copy_from_slice(&hash);
+    }
+
+    o
+}
+
 fn num_sanitized_leaves(num_bytes: usize) -> usize {
     let leaves = (num_bytes + HASHSIZE - 1) / HASHSIZE;
     leaves.next_power_of_two()