Merge mjkeating changes into local branch
This commit is contained in:
commit
77d4405b7a
@ -7,3 +7,4 @@ edition = "2018"
|
|||||||
[dependencies]
|
[dependencies]
|
||||||
bytes = "0.4.9"
|
bytes = "0.4.9"
|
||||||
ethereum-types = "0.4.0"
|
ethereum-types = "0.4.0"
|
||||||
|
hashing = { path = "../hashing" }
|
||||||
|
@ -79,6 +79,14 @@ mod tests {
|
|||||||
assert_eq!(ssz.drain(), vec![0; 32]);
|
assert_eq!(ssz.drain(), vec![0; 32]);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_ssz_encode_address() {
|
||||||
|
let h = Address::zero();
|
||||||
|
let mut ssz = SszStream::new();
|
||||||
|
ssz.append(&h);
|
||||||
|
assert_eq!(ssz.drain(), vec![0; 20]);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_ssz_encode_u8() {
|
fn test_ssz_encode_u8() {
|
||||||
let x: u8 = 0;
|
let x: u8 = 0;
|
||||||
|
123
eth2/utils/ssz/src/impl_tree_hash.rs
Normal file
123
eth2/utils/ssz/src/impl_tree_hash.rs
Normal file
@ -0,0 +1,123 @@
|
|||||||
|
extern crate hashing;
|
||||||
|
|
||||||
|
use self::hashing::canonical_hash;
|
||||||
|
use super::ethereum_types::{Address, H256};
|
||||||
|
use super::{merkle_hash, ssz_encode, TreeHash};
|
||||||
|
use std::cmp::Ord;
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use std::hash::Hash;
|
||||||
|
|
||||||
|
impl TreeHash for u8 {
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
ssz_encode(self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TreeHash for u16 {
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
ssz_encode(self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TreeHash for u32 {
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
ssz_encode(self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TreeHash for u64 {
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
ssz_encode(self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TreeHash for Address {
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
ssz_encode(self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TreeHash for H256 {
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
ssz_encode(self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TreeHash for [u8] {
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
hash(&self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> TreeHash for Vec<T>
|
||||||
|
where
|
||||||
|
T: TreeHash,
|
||||||
|
{
|
||||||
|
/// Returns the merkle_hash of a list of tree_hash 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 tree_hash(&self) -> Vec<u8> {
|
||||||
|
let mut tree_hashes = self.iter().map(|x| x.tree_hash()).collect();
|
||||||
|
merkle_hash(&mut tree_hashes)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<K, V> TreeHash for HashMap<K, V>
|
||||||
|
where
|
||||||
|
K: Eq,
|
||||||
|
K: Hash,
|
||||||
|
K: Ord,
|
||||||
|
V: TreeHash,
|
||||||
|
{
|
||||||
|
/// Appends the tree_hash for each value of 'self, sorted by key,
|
||||||
|
/// into a byte array and returns the hash of said byte array
|
||||||
|
fn tree_hash(&self) -> Vec<u8> {
|
||||||
|
let mut items: Vec<_> = self.iter().collect();
|
||||||
|
items.sort_by(|a, b| a.0.cmp(b.0));
|
||||||
|
let mut result = Vec::new();
|
||||||
|
for item in items {
|
||||||
|
result.append(&mut item.1.tree_hash());
|
||||||
|
}
|
||||||
|
|
||||||
|
hash(&result)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn hash(data: &[u8]) -> Vec<u8> {
|
||||||
|
canonical_hash(data)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_impl_tree_hash_vec() {
|
||||||
|
let result = vec![1u32, 2, 3, 4, 5, 6, 7].tree_hash();
|
||||||
|
assert_eq!(result.len(), 32);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_impl_tree_hash_hashmap() {
|
||||||
|
let mut map = HashMap::new();
|
||||||
|
map.insert("c", 3);
|
||||||
|
map.insert("b", 2);
|
||||||
|
map.insert("g", 7);
|
||||||
|
map.insert("d", 6);
|
||||||
|
map.insert("e", 4);
|
||||||
|
map.insert("a", 1u32);
|
||||||
|
map.insert("f", 5);
|
||||||
|
let result = map.tree_hash();
|
||||||
|
|
||||||
|
// TODO: create tests that tie-out to an offical result
|
||||||
|
assert_eq!(
|
||||||
|
result,
|
||||||
|
[
|
||||||
|
232, 63, 235, 91, 115, 69, 159, 54, 95, 239, 147, 30, 179, 96, 232, 210, 225, 31,
|
||||||
|
12, 95, 149, 104, 134, 158, 45, 51, 20, 101, 202, 164, 200, 163
|
||||||
|
]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
@ -12,12 +12,15 @@ extern crate ethereum_types;
|
|||||||
|
|
||||||
pub mod decode;
|
pub mod decode;
|
||||||
pub mod encode;
|
pub mod encode;
|
||||||
|
pub mod tree_hash;
|
||||||
|
|
||||||
mod impl_decode;
|
mod impl_decode;
|
||||||
mod impl_encode;
|
mod impl_encode;
|
||||||
|
mod impl_tree_hash;
|
||||||
|
|
||||||
pub use crate::decode::{decode_ssz, decode_ssz_list, Decodable, DecodeError};
|
pub use crate::decode::{decode_ssz, decode_ssz_list, Decodable, DecodeError};
|
||||||
pub use crate::encode::{Encodable, SszStream};
|
pub use crate::encode::{Encodable, SszStream};
|
||||||
|
pub use crate::tree_hash::{merkle_hash, TreeHash};
|
||||||
|
|
||||||
pub const LENGTH_BYTES: usize = 4;
|
pub const LENGTH_BYTES: usize = 4;
|
||||||
pub const MAX_LIST_SIZE: usize = 1 << (4 * 8);
|
pub const MAX_LIST_SIZE: usize = 1 << (4 * 8);
|
||||||
|
92
eth2/utils/ssz/src/tree_hash.rs
Normal file
92
eth2/utils/ssz/src/tree_hash.rs
Normal file
@ -0,0 +1,92 @@
|
|||||||
|
|
||||||
|
|
||||||
|
const SSZ_CHUNK_SIZE: usize = 128;
|
||||||
|
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 (chunk_size, mut data) = list_to_blob(list);
|
||||||
|
|
||||||
|
// get data_len as bytes. It will hashed will the merkle root
|
||||||
|
let dlen = list.len() as u64;
|
||||||
|
let data_len_bytes = &mut dlen.tree_hash();
|
||||||
|
data_len_bytes.resize(32, 0);
|
||||||
|
|
||||||
|
// merklize
|
||||||
|
let mut mhash = hash_level(&mut data, chunk_size);
|
||||||
|
while mhash.len() > HASHSIZE {
|
||||||
|
mhash = hash_level(&mut mhash, HASHSIZE);
|
||||||
|
}
|
||||||
|
|
||||||
|
mhash.append(data_len_bytes);
|
||||||
|
mhash.as_slice().tree_hash()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Takes a flat vector of bytes. It then hashes 'chunk_size * 2' slices into
|
||||||
|
/// a byte vector of hashes, divisible by HASHSIZE
|
||||||
|
fn hash_level(data: &mut Vec<u8>, chunk_size: usize) -> Vec<u8> {
|
||||||
|
let mut result: Vec<u8> = Vec::new();
|
||||||
|
for two_chunks in data.chunks(chunk_size * 2) {
|
||||||
|
if two_chunks.len() == chunk_size && data.len() > chunk_size {
|
||||||
|
// if there is only one chunk here, hash it with a zero-byte
|
||||||
|
// SSZ_CHUNK_SIZE vector
|
||||||
|
let mut c = two_chunks.to_vec();
|
||||||
|
c.append(&mut vec![0; SSZ_CHUNK_SIZE]);
|
||||||
|
result.append(&mut c.as_slice().tree_hash());
|
||||||
|
} else {
|
||||||
|
result.append(&mut two_chunks.tree_hash());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
result
|
||||||
|
}
|
||||||
|
|
||||||
|
fn list_to_blob(list: &mut Vec<Vec<u8>>) -> (usize, Vec<u8>) {
|
||||||
|
let chunk_size = if list.is_empty() {
|
||||||
|
SSZ_CHUNK_SIZE
|
||||||
|
} else if list[0].len() < SSZ_CHUNK_SIZE {
|
||||||
|
let items_per_chunk = SSZ_CHUNK_SIZE / list[0].len();
|
||||||
|
items_per_chunk * list[0].len()
|
||||||
|
} else {
|
||||||
|
list[0].len()
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut data = Vec::new();
|
||||||
|
if list.is_empty() {
|
||||||
|
// handle and empty list
|
||||||
|
data.append(&mut vec![0; SSZ_CHUNK_SIZE]);
|
||||||
|
} else {
|
||||||
|
// just create a blob here; we'll divide into
|
||||||
|
// chunked slices when we merklize
|
||||||
|
data.reserve(list[0].len() * list.len());
|
||||||
|
for item in list.iter_mut() {
|
||||||
|
data.append(item);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
(chunk_size, data)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_merkle_hash() {
|
||||||
|
let data1 = vec![1; 100];
|
||||||
|
let data2 = vec![2; 100];
|
||||||
|
let data3 = vec![3; 100];
|
||||||
|
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());
|
||||||
|
println!("merkle_hash: {:?}", result);
|
||||||
|
}
|
||||||
|
}
|
Loading…
Reference in New Issue
Block a user