grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

triehash cleanup in progress

Browse Source
This commit is contained in:
debris 2015-11-30 15:35:10 +01:00
parent be1d208c36
commit ec7ce060e4
2 changed files with 106 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/rlp.rs
View File

@ -148,7 +148,7 @@ impl<'a> Rlp<'a> {
/// assert_eq!(dog, &[0x83, b'd', b'o', b'g']); /// assert_eq!(dog, &[0x83, b'd', b'o', b'g']);
/// } /// }
/// ``` /// ```
pub fn data(&'a self) -> &'a [u8] { pub fn data(&self) -> &[u8] {
self.rlp.data() self.rlp.data()
} }
@ -329,7 +329,7 @@ impl<'a> UntrustedRlp<'a> {
/// assert_eq!(dog, &[0x83, b'd', b'o', b'g']); /// assert_eq!(dog, &[0x83, b'd', b'o', b'g']);
/// } /// }
/// ``` /// ```
pub fn data(&'a self) -> &'a [u8] { pub fn data(&self) -> &[u8] {
self.bytes self.bytes
} }
@ -1256,6 +1256,14 @@ mod tests {
run_encode_tests(tests); run_encode_tests(tests);
} }
#[test]
fn encode_bytes() {
let vec = vec![0u8];
let slice: &[u8] = &vec;
let res = rlp::encode(&slice);
assert_eq!(res, vec![0u8]);
}
#[test] #[test]
fn rlp_stream() { fn rlp_stream() {
let mut stream = RlpStream::new_list(2); let mut stream = RlpStream::new_list(2);

269
src/triehash.rs
View File

@ -8,6 +8,39 @@ use rlp;
use rlp::RlpStream; use rlp::RlpStream;
use vector::SharedPrefix; use vector::SharedPrefix;
pub fn ordered_trie_root(input: Vec<Vec<u8>>) -> H256 {
let gen_input = input
// 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(|p| p )
.collect();
gen_trie_root(gen_input)
}
pub fn trie_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
let gen_input = input
.into_iter()
.map(|(k, v)| (as_nibbles(&k), v))
.collect();
gen_trie_root(gen_input)
}
fn gen_trie_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
let mut stream = RlpStream::new();
hash256rlp(&input, 0, &mut stream);
stream.out().sha3()
}
/// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1. /// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1.
/// ///
/// The "termination marker" and "leaf-node" specifier are completely equivalent. /// The "termination marker" and "leaf-node" specifier are completely equivalent.
@ -65,7 +98,7 @@ use vector::SharedPrefix;
/// } /// }
/// ``` /// ```
/// ///
pub fn hex_prefix_encode(nibbles: &[u8], leaf: bool) -> Vec<u8> { fn hex_prefix_encode(nibbles: &[u8], leaf: bool) -> Vec<u8> {
let inlen = nibbles.len(); let inlen = nibbles.len();
let oddness_factor = inlen % 2; let oddness_factor = inlen % 2;
// next even number divided by two // next even number divided by two
@ -110,7 +143,7 @@ pub fn hex_prefix_encode(nibbles: &[u8], leaf: bool) -> Vec<u8> {
/// assert_eq!(as_nibbles(&v), e); /// assert_eq!(as_nibbles(&v), e);
/// } /// }
/// ``` /// ```
pub fn as_nibbles(bytes: &[u8]) -> Vec<u8> { fn as_nibbles(bytes: &[u8]) -> Vec<u8> {
let mut res = vec![]; let mut res = vec![];
res.reserve(bytes.len() * 2); res.reserve(bytes.len() * 2);
for i in 0..bytes.len() { for i in 0..bytes.len() {
@ -120,98 +153,44 @@ pub fn as_nibbles(bytes: &[u8]) -> Vec<u8> {
res res
} }
#[derive(Debug)] fn hash256rlp(input: &[(Vec<u8>, Vec<u8>)], pre_len: usize, stream: &mut RlpStream) {
pub struct NibblePair { let inlen = input.len();
nibble: Vec<u8>,
data: Vec<u8>
}
impl NibblePair {
pub fn new(nibble: Vec<u8>, data: Vec<u8>) -> NibblePair {
NibblePair {
nibble: nibble,
data: data
}
}
pub fn new_raw(to_nibble: Vec<u8>, data: Vec<u8>) -> NibblePair {
NibblePair::new(as_nibbles(&to_nibble), data)
}
}
fn nibble_shared_prefix_len(vec: &[NibblePair]) -> usize {
if vec.len() == 0 {
return 0;
}
vec.iter()
// skip first element
.skip(1)
// get minimum number of shared nibbles between first and each successive
.fold(vec[0].nibble.len(), | acc, pair | {
cmp::min(vec[0].nibble.shared_prefix_len(&pair.nibble), acc)
})
}
pub fn ordered_trie_root(data: Vec<Vec<u8>>) -> H256 {
let vec: Vec<NibblePair> = 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)
}
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()
}
};
out.sha3()
}
fn hash256rlp(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) {
let vlen = vec.len();
// in case of empty slice, just append null // in case of empty slice, just append null
if vlen == 0 { if inlen == 0 {
stream.append(&""); stream.append(&"");
return; return;
} }
// take slices
let key: &Vec<u8> = &input[0].0;
let value: &[u8] = &input[0].1;
// if the slice contains just one item, append the suffix of the key // if the slice contains just one item, append the suffix of the key
// and then append value // and then append value
if vlen == 1 { if inlen == 1 {
stream.append_list(2); stream.append_list(2);
stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..], true)); stream.append(&hex_prefix_encode(&key[pre_len..], true));
stream.append(&vec[0].data); stream.append(&value);
return; return;
} }
// get length of the longest shared prefix in slice keys // get length of the longest shared prefix in slice keys
let shared_prefix = nibble_shared_prefix_len(vec); let shared_prefix = input.iter()
// skip first element
.skip(1)
// get minimum number of shared nibbles between first and each successive
.fold(key.len(), | acc, &(ref k, _) | {
cmp::min(key.shared_prefix_len(&k), acc)
});
// if shared prefix is higher than current prefix append its // if shared prefix is higher than current prefix append its
// new part of the key to the stream // new part of the key to the stream
// then recursively append suffixes of all items who had this key // then recursively append suffixes of all items who had this key
if shared_prefix > pre_len { if shared_prefix > pre_len {
stream.append_list(2); stream.append_list(2);
stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..shared_prefix], false)); stream.append(&hex_prefix_encode(&key[pre_len..shared_prefix], false));
hash256aux(vec, shared_prefix, stream); hash256aux(input, shared_prefix, stream);
return; return;
} }
@ -220,7 +199,7 @@ fn hash256rlp(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) {
stream.append_list(17); stream.append_list(17);
// if first key len is equal to prefix_len, move to next element // if first key len is equal to prefix_len, move to next element
let mut begin = match pre_len == vec[0].nibble.len() { let mut begin = match pre_len == key.len() {
true => 1, true => 1,
false => 0 false => 0
}; };
@ -228,29 +207,29 @@ fn hash256rlp(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) {
// iterate over all possible nibbles // iterate over all possible nibbles
for i in 0..16 { for i in 0..16 {
// cout how many successive elements have same next nibble // cout how many successive elements have same next nibble
let len = vec[begin..].iter() let len = input[begin..].iter()
.map(| pair | pair.nibble[pre_len] ) .map(| pair | pair.0[pre_len] )
.take_while(|&q| q == i).count(); .take_while(|&q| q == i).count();
// if at least 1 successive element has the same nibble // if at least 1 successive element has the same nibble
// append their suffixes // append their suffixes
match len { match len {
0 => { stream.append(&""); }, 0 => { stream.append(&""); },
_ => hash256aux(&vec[begin..(begin + len)], pre_len + 1, stream) _ => hash256aux(&input[begin..(begin + len)], pre_len + 1, stream)
} }
begin += len; begin += len;
} }
// if fist key len is equal prefix, append it's value // if fist key len is equal prefix, append it's value
match pre_len == vec[0].nibble.len() { match pre_len == key.len() {
true => { stream.append(&vec[0].data); }, true => { stream.append(&value); },
false => { stream.append(&""); } false => { stream.append(&""); }
}; };
} }
fn hash256aux(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) { fn hash256aux(input: &[(Vec<u8>, Vec<u8>)], pre_len: usize, stream: &mut RlpStream) {
let mut s = RlpStream::new(); let mut s = RlpStream::new();
hash256rlp(vec, pre_len, &mut s); hash256rlp(input, pre_len, &mut s);
let out = s.out(); let out = s.out();
match out.len() { match out.len() {
0...31 => stream.append_raw(&out, 1), 0...31 => stream.append_raw(&out, 1),
@ -258,39 +237,6 @@ fn hash256aux(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) {
}; };
} }
#[test]
fn test_shared_nibble_len() {
let len = nibble_shared_prefix_len(&vec![
NibblePair::new(vec![0, 1, 2, 3, 4, 5, 6], vec![]),
NibblePair::new(vec![0, 1, 2, 3, 4, 5, 6], vec![]),
]);
assert_eq!(len , 7);
}
#[test]
fn test_shared_nibble_len2() {
let len = nibble_shared_prefix_len(&vec![
NibblePair::new(vec![0, 1, 2, 3, 4, 5, 6], vec![]),
NibblePair::new(vec![0, 1, 2, 3, 4, 5, 6], vec![]),
NibblePair::new(vec![4, 1, 2, 3, 4, 5, 6], vec![])
]);
assert_eq!(len , 0);
}
#[test]
fn test_shared_nibble_len3() {
let len = nibble_shared_prefix_len(&vec![
NibblePair::new(vec![0, 1, 2, 3, 4, 5, 6], vec![]),
NibblePair::new(vec![0, 1, 2, 3, 4, 5, 6], vec![]),
NibblePair::new(vec![0, 1, 2, 4, 4, 5, 6], vec![])
]);
assert_eq!(len , 3);
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::str::FromStr; use std::str::FromStr;
@ -298,106 +244,83 @@ mod tests {
use hash::*; use hash::*;
use triehash::*; use triehash::*;
#[test] #[test]
fn empty_trie_root() { fn empty_trie_root() {
assert_eq!(hash256(&vec![]), H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap()); assert_eq!(trie_root(vec![]), H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap());
} }
#[test] #[test]
fn single_trie_item() { fn single_trie_item() {
let v = vec![(From::from("A"), From::from("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))];
let v = vec![ assert_eq!(trie_root(v), H256::from_str("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab").unwrap());
NibblePair::new_raw(From::from("A"),
From::from("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
];
assert_eq!(hash256(&v), H256::from_str("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab").unwrap());
} }
#[test] #[test]
fn foo_trie_item() { fn foo_trie_item() {
let v = vec![ let v = vec![
NibblePair::new_raw(From::from("foo"), (From::from("foo"), From::from("bar")),
From::from("bar")), (From::from("food"), From::from("bass"))
NibblePair::new_raw(From::from("food"),
From::from("bass"))
]; ];
assert_eq!(hash256(&v), H256::from_str("17beaa1648bafa633cda809c90c04af50fc8aed3cb40d16efbddee6fdf63c4c3").unwrap()); assert_eq!(trie_root(v), H256::from_str("17beaa1648bafa633cda809c90c04af50fc8aed3cb40d16efbddee6fdf63c4c3").unwrap());
} }
#[test] #[test]
fn dogs_trie_item() { fn dogs_trie_item() {
let v = vec![ let v = vec![
NibblePair::new_raw(From::from("doe"), (From::from("doe"), From::from("reindeer")),
From::from("reindeer")), (From::from("dog"), From::from("puppy")),
(From::from("dogglesworth"), From::from("cat")),
NibblePair::new_raw(From::from("dog"),
From::from("puppy")),
NibblePair::new_raw(From::from("dogglesworth"),
From::from("cat")),
]; ];
assert_eq!(hash256(&v), H256::from_str("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3").unwrap()); assert_eq!(trie_root(v), H256::from_str("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3").unwrap());
} }
#[test] #[test]
fn puppy_trie_items() { fn puppy_trie_items() {
let v = vec![ let v = vec![
NibblePair::new_raw(From::from("do"), (From::from("do"), From::from("verb")),
From::from("verb")), (From::from("dog"), From::from("puppy")),
(From::from("doge"), From::from("coin")),
NibblePair::new_raw(From::from("dog"), (From::from("horse"), From::from("stallion")),
From::from("puppy")),
NibblePair::new_raw(From::from("doge"),
From::from("coin")),
NibblePair::new_raw(From::from("horse"),
From::from("stallion")),
]; ];
assert_eq!(hash256(&v), H256::from_str("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84").unwrap()); assert_eq!(trie_root(v), H256::from_str("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84").unwrap());
} }
#[test] #[test]
fn test_trie_root() { fn test_trie_root() {
let v = vec![ let v = vec![
NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000045".from_hex().unwrap(),
"22b224a1420a802ab51d326e29fa98e34c4f24ea".from_hex().unwrap()),
NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000046".from_hex().unwrap(), ("0000000000000000000000000000000000000000000000000000000000000045".from_hex().unwrap(),
"67706c2076330000000000000000000000000000000000000000000000000000".from_hex().unwrap()), "22b224a1420a802ab51d326e29fa98e34c4f24ea".from_hex().unwrap()),
NibblePair::new_raw("000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap(), ("0000000000000000000000000000000000000000000000000000000000000046".from_hex().unwrap(),
"6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap()), "67706c2076330000000000000000000000000000000000000000000000000000".from_hex().unwrap()),
NibblePair::new_raw("0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap(), ("000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap(),
"4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap()), "6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap()),
NibblePair::new_raw("000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap(), ("0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap(),
"4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap()), "4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap()),
NibblePair::new_raw("4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap(), ("000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap(),
"7ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap()), "4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap()),
NibblePair::new_raw("4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap(), ("4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap(),
"ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap()), "7ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap()),
("4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap(),
"ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap()),
("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(); assert_eq!(trie_root(v), H256::from_str("9f6221ebb8efe7cff60a716ecb886e67dd042014be444669f0159d8e68b42100").unwrap());
let res = hash256(&v);
assert_eq!(res, root);
} }
} }