diff --git a/eth2/utils/ssz/src/cached_tree_hash.rs b/eth2/utils/ssz/src/cached_tree_hash.rs index 99fd49221..756f97232 100644 --- a/eth2/utils/ssz/src/cached_tree_hash.rs +++ b/eth2/utils/ssz/src/cached_tree_hash.rs @@ -173,19 +173,6 @@ mod tests { all } - /* - #[test] - fn container() { - let data1 = hash(&vec![1; 32]); - let data2 = hash(&vec![2; 32]); - let data3 = hash(&vec![3; 32]); - let data4 = hash(&vec![4; 32]); - - let data = join(vec![&data1, &data2, &data3, &data4]); - - let cache = cache_builder(&data).unwrap(); - } - */ #[test] fn merkleize_4_leaves() { let data1 = hash(&int_to_bytes32(1)); @@ -232,226 +219,3 @@ mod tests { } } } -/* - -/// Get merkle root of some hashed values - the input leaf nodes is expected to already be hashed -/// Outputs a `Vec` byte array of the merkle root given a set of leaf node values. -pub fn cache_builder(values: &[u8]) -> Option> { - let leaves = values.len() / HASHSIZE; - - if leaves == 0 || !leaves.is_power_of_two() { - return None; - } - - let mut o: Vec = 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.get_mut(j..j + HASHSIZE)?.copy_from_slice(&hash); - } - - return Some(o); -} - -fn parent(child: usize) -> usize { - (child - 1) / 2 -} - -fn children(parent: usize) -> (usize, usize) { - ((2 * parent + 1), (2 * parent + 2)) -} - -fn num_nodes(num_leaves: usize) -> usize { - 2 * num_leaves - 1 -} - -pub struct Outer { - pub a: u64, - pub b: u64, - pub inner: Inner, -} - -#[cfg(test)] -mod tests { - use super::*; - - fn join(many: Vec<&[u8]>) -> Vec { - let mut all = vec![]; - for one in many { - all.extend_from_slice(&mut one.clone()) - } - all - } - - /* - #[test] - fn container() { - let data1 = hash(&vec![1; 32]); - let data2 = hash(&vec![2; 32]); - let data3 = hash(&vec![3; 32]); - let data4 = hash(&vec![4; 32]); - - let data = join(vec![&data1, &data2, &data3, &data4]); - - let cache = cache_builder(&data).unwrap(); - } - */ -#[test] -fn can_build_cache() { -let data1 = hash(&vec![1; 32]); -let data2 = hash(&vec![2; 32]); -let data3 = hash(&vec![3; 32]); -let data4 = hash(&vec![4; 32]); - -let data = join(vec![&data1, &data2, &data3, &data4]); - -let cache = cache_builder(&data).unwrap(); - -let hash_12 = { -let mut joined = vec![]; -joined.append(&mut data1.clone()); -joined.append(&mut data2.clone()); -hash(&joined) -}; -let hash_34 = { -let mut joined = vec![]; -joined.append(&mut data3.clone()); -joined.append(&mut data4.clone()); -hash(&joined) -}; -let hash_hash12_hash_34 = { -let mut joined = vec![]; -joined.append(&mut hash_12.clone()); -joined.append(&mut hash_34.clone()); -hash(&joined) -}; - -for (i, chunk) in cache.chunks(HASHSIZE).enumerate().rev() { -let expected = match i { -0 => hash_hash12_hash_34.clone(), -1 => hash_12.clone(), -2 => hash_34.clone(), -3 => data1.clone(), -4 => data2.clone(), -5 => data3.clone(), -6 => data4.clone(), -_ => vec![], -}; - -assert_eq!(chunk, &expected[..], "failed at {}", i); -} -} -} - -/* -pub trait TreeHash { - fn hash_tree_root(&self) -> Vec; -} - -/// 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 { - // 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 = 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 { - // 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, 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()); - } -} -*/ -*/