Create cached_tree_hash crate.

eth2/utils/cached_tree_hash/src/impls/vec.rs

@@ -0,0 +1,202 @@
+use super::*;
+use crate::merkleize::{merkleize, num_sanitized_leaves, sanitise_bytes};
+
+impl<T> CachedTreeHash<Vec<T>> for Vec<T>
+where
+    T: CachedTreeHash<T> + TreeHash,
+{
+    fn new_tree_hash_cache(&self, depth: usize) -> Result<TreeHashCache, Error> {
+        let overlay = self.tree_hash_cache_overlay(0, depth)?;
+
+        let mut cache = match T::tree_hash_type() {
+            TreeHashType::Basic => TreeHashCache::from_bytes(
+                merkleize(get_packed_leaves(self)?),
+                false,
+                Some(overlay.clone()),
+            ),
+            TreeHashType::Container | TreeHashType::List | TreeHashType::Vector => {
+                let subtrees = self
+                    .iter()
+                    .map(|item| TreeHashCache::new(item, depth + 1))
+                    .collect::<Result<Vec<TreeHashCache>, _>>()?;
+
+                TreeHashCache::from_leaves_and_subtrees(self, subtrees, depth)
+            }
+        }?;
+
+        cache.add_length_nodes(overlay.chunk_range(), self.len())?;
+
+        Ok(cache)
+    }
+
+    fn num_tree_hash_cache_chunks(&self) -> usize {
+        BTreeOverlay::new(self, 0, 0)
+            .and_then(|o| Ok(o.num_chunks()))
+            .unwrap_or_else(|_| 1)
+            + 2
+    }
+
+    fn tree_hash_cache_overlay(
+        &self,
+        chunk_offset: usize,
+        depth: usize,
+    ) -> Result<BTreeOverlay, Error> {
+        let lengths = match T::tree_hash_type() {
+            TreeHashType::Basic => {
+                // Ceil division.
+                let num_leaves = (self.len() + T::tree_hash_packing_factor() - 1)
+                    / T::tree_hash_packing_factor();
+
+                // Disallow zero-length as an empty list still has one all-padding node.
+                vec![1; std::cmp::max(1, num_leaves)]
+            }
+            TreeHashType::Container | TreeHashType::List | TreeHashType::Vector => {
+                let mut lengths = vec![];
+
+                for item in self {
+                    lengths.push(item.num_tree_hash_cache_chunks())
+                }
+
+                // Disallow zero-length as an empty list still has one all-padding node.
+                if lengths.is_empty() {
+                    lengths.push(1);
+                }
+
+                lengths
+            }
+        };
+
+        BTreeOverlay::from_lengths(chunk_offset, self.len(), depth, lengths)
+    }
+
+    fn update_tree_hash_cache(&self, cache: &mut TreeHashCache) -> Result<(), Error> {
+        // Skip the length-mixed-in root node.
+        cache.chunk_index += 1;
+
+        let old_overlay = cache.get_overlay(cache.overlay_index, cache.chunk_index)?;
+        let new_overlay = BTreeOverlay::new(self, cache.chunk_index, old_overlay.depth)?;
+
+        cache.replace_overlay(cache.overlay_index, cache.chunk_index, new_overlay.clone())?;
+
+        cache.overlay_index += 1;
+
+        match T::tree_hash_type() {
+            TreeHashType::Basic => {
+                let mut buf = vec![0; HASHSIZE];
+                let item_bytes = HASHSIZE / T::tree_hash_packing_factor();
+
+                // Iterate through each of the leaf nodes.
+                for i in 0..new_overlay.num_leaf_nodes() {
+                    // Iterate through the number of items that may be packing into the leaf node.
+                    for j in 0..T::tree_hash_packing_factor() {
+                        // Create a mut slice that can be filled with either a serialized item or
+                        // padding.
+                        let buf_slice = &mut buf[j * item_bytes..(j + 1) * item_bytes];
+
+                        // Attempt to get the item for this portion of the chunk. If it exists,
+                        // update `buf` with it's serialized bytes. If it doesn't exist, update
+                        // `buf` with padding.
+                        match self.get(i * T::tree_hash_packing_factor() + j) {
+                            Some(item) => {
+                                buf_slice.copy_from_slice(&item.tree_hash_packed_encoding());
+                            }
+                            None => buf_slice.copy_from_slice(&vec![0; item_bytes]),
+                        }
+                    }
+
+                    // Update the chunk if the generated `buf` is not the same as the cache.
+                    let chunk = new_overlay.first_leaf_node() + i;
+                    cache.maybe_update_chunk(chunk, &buf)?;
+                }
+            }
+            TreeHashType::Container | TreeHashType::List | TreeHashType::Vector => {
+                for i in 0..new_overlay.num_leaf_nodes() {
+                    // Adjust `i` so it is a leaf node for each of the overlays.
+                    let old_i = i + old_overlay.num_internal_nodes();
+                    let new_i = i + new_overlay.num_internal_nodes();
+
+                    match (
+                        old_overlay.get_leaf_node(old_i)?,
+                        new_overlay.get_leaf_node(new_i)?,
+                    ) {
+                        // The item existed in the previous list and exists in the current list.
+                        (Some(_old), Some(new)) => {
+                            cache.chunk_index = new.start;
+
+                            self[i].update_tree_hash_cache(cache)?;
+                        }
+                        // The item did not exist in the previous list but does exist in this list.
+                        //
+                        // Viz., the list has been lengthened.
+                        (None, Some(new)) => {
+                            let (bytes, mut bools, overlays) =
+                                TreeHashCache::new(&self[i], new_overlay.depth + 1)?
+                                    .into_components();
+
+                            // Record the number of overlays, this will be used later in the fn.
+                            let num_overlays = overlays.len();
+
+                            // Flag the root node of the new tree as dirty.
+                            bools[0] = true;
+
+                            cache.splice(new.start..new.start + 1, bytes, bools);
+                            cache
+                                .overlays
+                                .splice(cache.overlay_index..cache.overlay_index, overlays);
+
+                            cache.overlay_index += num_overlays;
+                        }
+                        // The item existed in the previous list but does not exist in this list.
+                        //
+                        // Viz., the list has been shortened.
+                        (Some(old), None) => {
+                            if new_overlay.num_items == 0 {
+                                // In this case, the list has been made empty and we should make
+                                // this node padding.
+                                cache.maybe_update_chunk(new_overlay.root(), &[0; HASHSIZE])?;
+                            } else {
+                                // In this case, there are some items in the new list and we should
+                                // splice out the entire tree of the removed node, replacing it
+                                // with a single padding node.
+                                cache.splice(old, vec![0; HASHSIZE], vec![true]);
+                            }
+                        }
+                        // The item didn't exist in the old list and doesn't exist in the new list,
+                        // nothing to do.
+                        (None, None) => {}
+                    }
+                }
+
+                // Clean out any excess overlays that may or may not be remaining if the list was
+                // shortened.
+                cache.remove_proceeding_child_overlays(cache.overlay_index, new_overlay.depth);
+            }
+        }
+
+        cache.update_internal_nodes(&new_overlay)?;
+
+        // Mix in length
+        cache.mix_in_length(new_overlay.chunk_range(), self.len())?;
+
+        // Skip an extra node to clear the length node.
+        cache.chunk_index = new_overlay.next_node() + 1;
+
+        Ok(())
+    }
+}
+
+fn get_packed_leaves<T>(vec: &Vec<T>) -> Result<Vec<u8>, Error>
+where
+    T: CachedTreeHash<T>,
+{
+    let num_packed_bytes = (BYTES_PER_CHUNK / T::tree_hash_packing_factor()) * vec.len();
+    let num_leaves = num_sanitized_leaves(num_packed_bytes);
+
+    let mut packed = Vec::with_capacity(num_leaves * HASHSIZE);
+
+    for item in vec {
+        packed.append(&mut item.tree_hash_packed_encoding());
+    }
+
+    Ok(sanitise_bytes(packed))
+}