Add uncached tree hashing

eth2/utils/tree_hash/src/lib.rs

@@ -1,33 +1,10 @@
-use hashing::hash;
-use int_to_bytes::int_to_bytes32;
-use std::ops::Range;
-
-mod btree_overlay;
-mod cached_tree_hash;
-mod impls;
-mod resize;
-
-pub use btree_overlay::BTreeOverlay;
-pub use cached_tree_hash::TreeHashCache;
+pub mod cached_tree_hash;
+pub mod standard_tree_hash;
 
 pub const BYTES_PER_CHUNK: usize = 32;
 pub const HASHSIZE: usize = 32;
 pub const MERKLE_HASH_CHUNCK: usize = 2 * BYTES_PER_CHUNK;
 
-#[derive(Debug, PartialEq, Clone)]
-pub enum Error {
-    ShouldNotProduceBTreeOverlay,
-    NoFirstNode,
-    NoBytesForRoot,
-    UnableToObtainSlices,
-    UnableToGrowMerkleTree,
-    UnableToShrinkMerkleTree,
-    ShouldNeverBePacked(ItemType),
-    BytesAreNotEvenChunks(usize),
-    NoModifiedFieldForChunk(usize),
-    NoBytesForChunk(usize),
-}
-
 #[derive(Debug, PartialEq, Clone)]
 pub enum ItemType {
     Basic,
@@ -35,114 +12,11 @@ pub enum ItemType {
     Composite,
 }
 
-pub trait CachedTreeHash<T>: CachedTreeHashSubTree<T> + Sized {
-    fn update_internal_tree_hash_cache(self, old: T) -> Result<(Self, Self), Error>;
-
-    fn cached_tree_hash_root(&self) -> Option<Vec<u8>>;
-
-    fn clone_without_tree_hash_cache(&self) -> Self;
-}
-
-pub trait CachedTreeHashSubTree<Item> {
-    fn item_type() -> ItemType;
-
-    fn btree_overlay(&self, chunk_offset: usize) -> Result<BTreeOverlay, Error>;
-
-    fn packed_encoding(&self) -> Result<Vec<u8>, Error>;
-
-    fn packing_factor() -> usize;
-
-    fn new_cache(&self) -> Result<TreeHashCache, Error>;
-
-    fn update_cache(
-        &self,
-        other: &Item,
-        cache: &mut TreeHashCache,
-        chunk: usize,
-    ) -> Result<usize, Error>;
-}
-
-fn children(parent: usize) -> (usize, usize) {
-    ((2 * parent + 1), (2 * parent + 2))
-}
-
-fn num_nodes(num_leaves: usize) -> usize {
-    2 * num_leaves - 1
-}
-
-fn node_range_to_byte_range(node_range: &Range<usize>) -> Range<usize> {
-    node_range.start * HASHSIZE..node_range.end * HASHSIZE
-}
-
-/// Split `values` into a power-of-two, identical-length chunks (padding with `0`) and merkleize
-/// them, returning the entire merkle tree.
-///
-/// The root hash is `merkleize(values)[0..BYTES_PER_CHUNK]`.
-pub fn merkleize(values: Vec<u8>) -> Vec<u8> {
-    let values = sanitise_bytes(values);
-
-    let leaves = values.len() / HASHSIZE;
-
-    if leaves == 0 {
-        panic!("No full leaves");
-    }
-
-    if !leaves.is_power_of_two() {
-        panic!("leaves is not power of two");
-    }
-
-    let mut o: Vec<u8> = vec![0; (num_nodes(leaves) - leaves) * HASHSIZE];
-    o.append(&mut values.to_vec());
-
-    let mut i = o.len();
-    let mut j = o.len() - values.len();
-
-    while i >= MERKLE_HASH_CHUNCK {
-        i -= MERKLE_HASH_CHUNCK;
-        let hash = hash(&o[i..i + MERKLE_HASH_CHUNCK]);
-
-        j -= HASHSIZE;
-        o[j..j + HASHSIZE].copy_from_slice(&hash);
-    }
-
-    o
-}
-
-pub fn sanitise_bytes(mut bytes: Vec<u8>) -> Vec<u8> {
-    let present_leaves = num_unsanitized_leaves(bytes.len());
-    let required_leaves = present_leaves.next_power_of_two();
-
-    if (present_leaves != required_leaves) | last_leaf_needs_padding(bytes.len()) {
-        bytes.resize(num_bytes(required_leaves), 0);
-    }
-
-    bytes
-}
-
-fn pad_for_leaf_count(num_leaves: usize, bytes: &mut Vec<u8>) {
-    let required_leaves = num_leaves.next_power_of_two();
-
-    bytes.resize(
-        bytes.len() + (required_leaves - num_leaves) * BYTES_PER_CHUNK,
-        0,
-    );
-}
-
-fn last_leaf_needs_padding(num_bytes: usize) -> bool {
-    num_bytes % HASHSIZE != 0
-}
-
-/// Rounds up
-fn num_unsanitized_leaves(num_bytes: usize) -> usize {
-    (num_bytes + HASHSIZE - 1) / HASHSIZE
-}
-
-/// Rounds up
 fn num_sanitized_leaves(num_bytes: usize) -> usize {
     let leaves = (num_bytes + HASHSIZE - 1) / HASHSIZE;
     leaves.next_power_of_two()
 }
 
-fn num_bytes(num_leaves: usize) -> usize {
-    num_leaves * HASHSIZE
+fn num_nodes(num_leaves: usize) -> usize {
+    2 * num_leaves - 1
 }