diff --git a/src/triehash.rs b/src/triehash.rs index 6f9490cc1..ad553cf70 100644 --- a/src/triehash.rs +++ b/src/triehash.rs @@ -1,300 +1,299 @@ //! Generete trie root -//use std::collections::BTreeMap; -//use std::cmp; -//use hash::*; -//use sha3::*; -//use rlp; -//use rlp::RlpStream; -//use vector::SharedPrefix; +use std::collections::BTreeMap; +use std::cmp; +use hash::*; +use sha3::*; +use rlp; +use rlp::RlpStream; +use vector::SharedPrefix; -///// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1. -///// -///// The "termination marker" and "leaf-node" specifier are completely equivalent. -///// -///// Input values are in range `[0, 0xf]`. -///// -///// ```markdown -///// [0,0,1,2,3,4,5] 0x10012345 // 7 > 4 -///// [0,1,2,3,4,5] 0x00012345 // 6 > 4 -///// [1,2,3,4,5] 0x112345 // 5 > 3 -///// [0,0,1,2,3,4] 0x00001234 // 6 > 3 -///// [0,1,2,3,4] 0x101234 // 5 > 3 -///// [1,2,3,4] 0x001234 // 4 > 3 -///// [0,0,1,2,3,4,5,T] 0x30012345 // 7 > 4 -///// [0,0,1,2,3,4,T] 0x20001234 // 6 > 4 -///// [0,1,2,3,4,5,T] 0x20012345 // 6 > 4 -///// [1,2,3,4,5,T] 0x312345 // 5 > 3 -///// [1,2,3,4,T] 0x201234 // 4 > 3 -///// ``` -///// -///// ```rust -///// extern crate ethcore_util as util; -///// use util::triehash::*; -///// -///// fn main() { -///// let v = vec![0, 0, 1, 2, 3, 4, 5]; -///// let e = vec![0x10, 0x01, 0x23, 0x45]; -///// let h = hex_prefix_encode(&v, false); -///// assert_eq!(h, e); -///// -///// let v = vec![0, 1, 2, 3, 4, 5]; -///// let e = vec![0x00, 0x01, 0x23, 0x45]; -///// let h = hex_prefix_encode(&v, false); -///// assert_eq!(h, e); -///// -///// let v = vec![0, 1, 2, 3, 4, 5]; -///// let e = vec![0x20, 0x01, 0x23, 0x45]; -///// let h = hex_prefix_encode(&v, true); -///// assert_eq!(h, e); -///// -///// let v = vec![1, 2, 3, 4, 5]; -///// let e = vec![0x31, 0x23, 0x45]; -///// let h = hex_prefix_encode(&v, true); -///// assert_eq!(h, e); -///// -///// let v = vec![1, 2, 3, 4]; -///// let e = vec![0x00, 0x12, 0x34]; -///// let h = hex_prefix_encode(&v, false); -///// assert_eq!(h, e); -///// -///// let v = vec![4, 1]; -///// let e = vec![0x20, 0x41]; -///// let h = hex_prefix_encode(&v, true); -///// assert_eq!(h, e); -///// } -///// ``` -///// -//pub fn hex_prefix_encode(nibbles: &[u8], leaf: bool) -> Vec { - //let inlen = nibbles.len(); - //let oddness_factor = inlen % 2; - //// next even number divided by two - //let reslen = (inlen + 2) >> 1; - //let mut res = vec![]; - //res.reserve(reslen); +/// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1. +/// +/// The "termination marker" and "leaf-node" specifier are completely equivalent. +/// +/// Input values are in range `[0, 0xf]`. +/// +/// ```markdown +/// [0,0,1,2,3,4,5] 0x10012345 // 7 > 4 +/// [0,1,2,3,4,5] 0x00012345 // 6 > 4 +/// [1,2,3,4,5] 0x112345 // 5 > 3 +/// [0,0,1,2,3,4] 0x00001234 // 6 > 3 +/// [0,1,2,3,4] 0x101234 // 5 > 3 +/// [1,2,3,4] 0x001234 // 4 > 3 +/// [0,0,1,2,3,4,5,T] 0x30012345 // 7 > 4 +/// [0,0,1,2,3,4,T] 0x20001234 // 6 > 4 +/// [0,1,2,3,4,5,T] 0x20012345 // 6 > 4 +/// [1,2,3,4,5,T] 0x312345 // 5 > 3 +/// [1,2,3,4,T] 0x201234 // 4 > 3 +/// ``` +/// +/// ```rust +/// extern crate ethcore_util as util; +/// use util::triehash::*; +/// +/// fn main() { +/// let v = vec![0, 0, 1, 2, 3, 4, 5]; +/// let e = vec![0x10, 0x01, 0x23, 0x45]; +/// let h = hex_prefix_encode(&v, false); +/// assert_eq!(h, e); +/// +/// let v = vec![0, 1, 2, 3, 4, 5]; +/// let e = vec![0x00, 0x01, 0x23, 0x45]; +/// let h = hex_prefix_encode(&v, false); +/// assert_eq!(h, e); +/// +/// let v = vec![0, 1, 2, 3, 4, 5]; +/// let e = vec![0x20, 0x01, 0x23, 0x45]; +/// let h = hex_prefix_encode(&v, true); +/// assert_eq!(h, e); +/// +/// let v = vec![1, 2, 3, 4, 5]; +/// let e = vec![0x31, 0x23, 0x45]; +/// let h = hex_prefix_encode(&v, true); +/// assert_eq!(h, e); +/// +/// let v = vec![1, 2, 3, 4]; +/// let e = vec![0x00, 0x12, 0x34]; +/// let h = hex_prefix_encode(&v, false); +/// assert_eq!(h, e); +/// +/// let v = vec![4, 1]; +/// let e = vec![0x20, 0x41]; +/// let h = hex_prefix_encode(&v, true); +/// assert_eq!(h, e); +/// } +/// ``` +/// +pub fn hex_prefix_encode(nibbles: &[u8], leaf: bool) -> Vec { + let inlen = nibbles.len(); + let oddness_factor = inlen % 2; + // next even number divided by two + let reslen = (inlen + 2) >> 1; + let mut res = vec![]; + res.reserve(reslen); - //let first_byte = { - //let mut bits = ((inlen as u8 & 1) + (2 * leaf as u8)) << 4; - //if oddness_factor == 1 { - //bits += nibbles[0]; - //} - //bits - //}; + let first_byte = { + let mut bits = ((inlen as u8 & 1) + (2 * leaf as u8)) << 4; + if oddness_factor == 1 { + bits += nibbles[0]; + } + bits + }; - //res.push(first_byte); + res.push(first_byte); - //let mut offset = oddness_factor; - //while offset < inlen { - //let byte = (nibbles[offset] << 4) + nibbles[offset + 1]; - //res.push(byte); - //offset += 2; - //} + let mut offset = oddness_factor; + while offset < inlen { + let byte = (nibbles[offset] << 4) + nibbles[offset + 1]; + res.push(byte); + offset += 2; + } - //res -//} + res +} -///// Converts slice of bytes to nibbles. -///// -///// ```rust -///// extern crate ethcore_util as util; -///// use util::triehash::*; -///// -///// fn main () { -///// let v = vec![0x31, 0x23, 0x45]; -///// let e = vec![3, 1, 2, 3, 4, 5]; -///// assert_eq!(as_nibbles(&v), e); -///// -///// // A => 65 => 0x41 => [4, 1] -///// let v: Vec = From::from("A"); -///// let e = vec![4, 1]; -///// assert_eq!(as_nibbles(&v), e); -///// } -///// ``` -//pub fn as_nibbles(bytes: &[u8]) -> Vec { - //let mut res = vec![]; - //res.reserve(bytes.len() * 2); - //for i in 0..bytes.len() { - //res.push(bytes[i] >> 4); - //res.push((bytes[i] << 4) >> 4); - //} - //res -//} +/// Converts slice of bytes to nibbles. +/// +/// ```rust +/// extern crate ethcore_util as util; +/// use util::triehash::*; +/// +/// fn main () { +/// let v = vec![0x31, 0x23, 0x45]; +/// let e = vec![3, 1, 2, 3, 4, 5]; +/// assert_eq!(as_nibbles(&v), e); +/// +/// // A => 65 => 0x41 => [4, 1] +/// let v: Vec = From::from("A"); +/// let e = vec![4, 1]; +/// assert_eq!(as_nibbles(&v), e); +/// } +/// ``` +pub fn as_nibbles(bytes: &[u8]) -> Vec { + let mut res = vec![]; + res.reserve(bytes.len() * 2); + for i in 0..bytes.len() { + res.push(bytes[i] >> 4); + res.push((bytes[i] << 4) >> 4); + } + res +} -//#[derive(Debug)] -//pub struct NibblePair { - //nibble: Vec, - //data: Vec -//} +#[derive(Debug)] +pub struct NibblePair { + nibble: Vec, + data: Vec +} -//impl NibblePair { - //pub fn new(nibble: Vec, data: Vec) -> NibblePair { - //NibblePair { - //nibble: nibble, - //data: data - //} - //} +impl NibblePair { + pub fn new(nibble: Vec, data: Vec) -> NibblePair { + NibblePair { + nibble: nibble, + data: data + } + } - //pub fn new_raw(to_nibble: Vec, data: Vec) -> NibblePair { - //NibblePair::new(as_nibbles(&to_nibble), data) - //} -//} + pub fn new_raw(to_nibble: Vec, data: Vec) -> NibblePair { + NibblePair::new(as_nibbles(&to_nibble), data) + } +} -//pub fn ordered_trie_root(data: Vec>) -> H256 { - //let vec: Vec = data - //// first put elements into btree to sort them by nibbles - //// optimize it later - //.into_iter() - //.fold(BTreeMap::new(), | mut acc, vec | { - //let len = acc.len(); - //acc.insert(as_nibbles(&rlp::encode(&len)), vec); - //acc - //}) - //// then move them to a vector - //.into_iter() - //.map(|(k, v)| NibblePair::new(k, v) ) - //.collect(); +pub fn ordered_trie_root(data: Vec>) -> H256 { + let vec: Vec = data + // first put elements into btree to sort them by nibbles + // optimize it later + .into_iter() + .fold(BTreeMap::new(), | mut acc, vec | { + let len = acc.len(); + acc.insert(as_nibbles(&rlp::encode(&len)), vec); + acc + }) + // then move them to a vector + .into_iter() + .map(|(k, v)| NibblePair::new(k, v) ) + .collect(); - //hash256(&vec) -//} + hash256(&vec) +} -//pub fn hash256(vec: &[NibblePair]) -> H256 { - //let out = match vec.len() { - //0 => rlp::encode(&""), - //_ => { - //let mut stream = RlpStream::new(); - //hash256rlp(&vec, 0, &mut stream); - //stream.out().unwrap() - //} - //}; +pub fn hash256(vec: &[NibblePair]) -> H256 { + let out = match vec.len() { + 0 => rlp::encode(&""), + _ => { + let mut stream = RlpStream::new(); + hash256rlp(&vec, 0, &mut stream); + stream.out().unwrap() + } + }; - //println!("out: {:?}", out); - //out.sha3() -//} + println!("out: {:?}", out); + out.sha3() +} -//fn hash256rlp(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) { - //match vec.len() { - //0 => { - //stream.append(&""); - //}, - //1 => { - //stream.append_list(2); - //stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..], true)); - //stream.append(&vec[0].data); - //}, - //_ => { - //let shared_prefix = vec.iter() - //// skip first element - //.skip(1) - //// get minimum number of shared nibbles between first and each successive - //.fold(usize::max_value(), | acc, pair | { - //cmp::min(vec[0].nibble.shared_prefix_len(&pair.nibble), acc) - //}); +fn hash256rlp(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) { + match vec.len() { + 0 => { + stream.append(&""); + }, + 1 => { + stream.append_list(2); + stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..], true)); + stream.append(&vec[0].data); + }, + _ => { + let shared_prefix = vec.iter() + // skip first element + .skip(1) + // get minimum number of shared nibbles between first and each successive + .fold(usize::max_value(), | acc, pair | { + cmp::min(vec[0].nibble.shared_prefix_len(&pair.nibble), acc) + }); - //match shared_prefix > pre_len { - //true => { - //stream.append_list(2); - //stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..shared_prefix], false)); - //hash256aux(vec, shared_prefix, stream); - //}, - //false => { - //stream.append_list(17); + match shared_prefix > pre_len { + true => { + stream.append_list(2); + stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..shared_prefix], false)); + hash256aux(vec, shared_prefix, stream); + }, + false => { + stream.append_list(17); - //// every nibble is longer then previous one - //let iter = vec.iter() - //// move to first element with len different then pre_len - //.take_while(| pair | { pair.nibble.len() == pre_len }); + // every nibble is longer then previous one + let iter = vec.iter() + // move to first element with len different then pre_len + .take_while(| pair | { pair.nibble.len() == pre_len }); - //let mut begin = iter.count(); + let mut begin = iter.count(); - //for i in 0..16 { - //// cout how many successive elements have same next nibble - //let len = vec[begin..].iter() - //.map(| pair | pair.nibble[pre_len] ) - //.take_while(|&q| q == i).count(); + for i in 0..16 { + // cout how many successive elements have same next nibble + let len = vec[begin..].iter() + .map(| pair | pair.nibble[pre_len] ) + .take_while(|&q| q == i).count(); - //match len { - //0 => { stream.append(&""); }, - //_ => hash256aux(&vec[begin..begin + len], pre_len + 1, stream) - //} - //begin += len; - //} + match len { + 0 => { stream.append(&""); }, + _ => hash256aux(&vec[begin..begin + len], pre_len + 1, stream) + } + begin += len; + } - //match pre_len == vec[0].nibble.len() { - //true => stream.append(&vec[0].data), - //false => stream.append(&"") - //}; - //} - //} - //} - //}; -//} + match pre_len == vec[0].nibble.len() { + true => stream.append(&vec[0].data), + false => stream.append(&"") + }; + } + } + } + }; +} -//fn hash256aux(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) { - //let mut s = RlpStream::new(); - //hash256rlp(vec, pre_len, &mut s); - //let out = s.out().unwrap(); - //match out.len() { - //0...31 => stream.append_raw(&out, 1), - //_ => stream.append(&out.sha3()) - //}; -//} +fn hash256aux(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) { + let mut s = RlpStream::new(); + hash256rlp(vec, pre_len, &mut s); + let out = s.out().unwrap(); + match out.len() { + 0...31 => stream.append_raw(&out, 1), + _ => stream.append(&out.sha3()) + }; +} -//#[cfg(test)] -//mod tests { - //use std::str::FromStr; - //use rustc_serialize::hex::FromHex; - //use hash::*; - //use triehash::*; +#[cfg(test)] +mod tests { + use std::str::FromStr; + use rustc_serialize::hex::FromHex; + use hash::*; + use triehash::*; - //#[test] - //fn empty_trie_root() { - //assert_eq!(hash256(&vec![]), H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap()); - //} + #[test] + fn empty_trie_root() { + assert_eq!(hash256(&vec![]), H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap()); + } - //#[test] - //fn single_trie_item() { + #[test] + fn single_trie_item() { - //let v = vec![ - //NibblePair::new_raw(From::from("A"), - //From::from("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")) - //]; - //println!("{:?}", v); - //assert_eq!(hash256(&v), H256::from_str("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab").unwrap()); - //} + let v = vec![ + NibblePair::new_raw(From::from("A"), + From::from("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")) + ]; + + assert_eq!(hash256(&v), H256::from_str("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab").unwrap()); + } - //#[test] - //fn test_trie_root() { - //let v = vec![ - //NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000045".from_hex().unwrap(), - //"22b224a1420a802ab51d326e29fa98e34c4f24ea".from_hex().unwrap()), + #[test] + fn test_trie_root() { + let _v = vec![ + NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000045".from_hex().unwrap(), + "22b224a1420a802ab51d326e29fa98e34c4f24ea".from_hex().unwrap()), - //NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000046".from_hex().unwrap(), - //"67706c2076330000000000000000000000000000000000000000000000000000".from_hex().unwrap()), + NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000046".from_hex().unwrap(), + "67706c2076330000000000000000000000000000000000000000000000000000".from_hex().unwrap()), - //NibblePair::new_raw("000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap(), - //"6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap()), + NibblePair::new_raw("000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap(), + "6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap()), - //NibblePair::new_raw("0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap(), - //"4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap()), + NibblePair::new_raw("0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap(), + "4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap()), - //NibblePair::new_raw("000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap(), - //"4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap()), + NibblePair::new_raw("000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap(), + "4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap()), - //NibblePair::new_raw("4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap(), - //"7ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap()), + NibblePair::new_raw("4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap(), + "7ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap()), - //NibblePair::new_raw("4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap(), - //"ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap()), + NibblePair::new_raw("4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap(), + "ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap()), - //NibblePair::new_raw("6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap(), - //"697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap()) - //]; + NibblePair::new_raw("6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap(), + "697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap()) + ]; - //let root = H256::from_str("9f6221ebb8efe7cff60a716ecb886e67dd042014be444669f0159d8e68b42100").unwrap(); + let _root = H256::from_str("9f6221ebb8efe7cff60a716ecb886e67dd042014be444669f0159d8e68b42100").unwrap(); //let res = hash256(&v); - //println!("{:?}", res); - ////assert!(false); - //} -//} + //assert_eq!(res, root); + } +}