poanetwork
/
parity-common
mirror of https://github.com/poanetwork/parity-common.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

more generic: hash256rlp and hash256aux takes a Hasher

This commit is contained in:
David Palm 2018-07-06 18:11:53 +02:00
parent b471d516dd
commit 7d309b2309
1 changed files with 39 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
triehash/src/lib.rs
View File

@ -28,8 +28,6 @@ extern crate rlp;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::cmp; use std::cmp;
use elastic_array::{ElasticArray4, ElasticArray8}; use elastic_array::{ElasticArray4, ElasticArray8};
// use ethereum_types::H256;
use hash::keccak;
use hashdb::Hasher; use hashdb::Hasher;
use rlp::RlpStream; use rlp::RlpStream;
@ -49,13 +47,14 @@ fn shared_prefix_len<T: Eq>(first: &[T], second: &[T]) -> usize {
/// fn main() { /// fn main() {
/// let v = &["doe", "reindeer"]; /// let v = &["doe", "reindeer"];
/// let root = "e766d5d51b89dc39d981b41bda63248d7abce4f0225eefd023792a540bcffee3"; /// let root = "e766d5d51b89dc39d981b41bda63248d7abce4f0225eefd023792a540bcffee3";
/// assert_eq!(ordered_trie_root::<_, _, KeccakHasher>(v), root.into()); /// assert_eq!(ordered_trie_root::<KeccakHasher, _, _>(v), root.into());
/// } /// }
/// ``` /// ```
pub fn ordered_trie_root<I, A, H>(input: I) -> H::Out // TODO: return value here pub fn ordered_trie_root<H, I, A>(input: I) -> H::Out
where I: IntoIterator<Item = A>, where I: IntoIterator<Item = A>,
A: AsRef<[u8]>, A: AsRef<[u8]>,
H: Hasher, H: Hasher,
<H as hashdb::Hasher>::Out: cmp::Ord + rlp::Encodable,
{ {
let gen_input: Vec<_> = input let gen_input: Vec<_> = input
// first put elements into btree to sort them by nibbles (key'd by index) // first put elements into btree to sort them by nibbles (key'd by index)
@ -69,8 +68,7 @@ pub fn ordered_trie_root<I, A, H>(input: I) -> H::Out // TODO: return value here
.map(|(k, v)| (as_nibbles(&k), v) ) .map(|(k, v)| (as_nibbles(&k), v) )
.collect(); .collect();
// gen_trie_root::<H,_, _>(&gen_input) // TODO: should be able to infer this gen_trie_root::<H,_, _>(&gen_input)
gen_trie_root::<_, _, H>(&gen_input) // TODO: should be able to infer this
} }
/// Generates a trie root hash for a vector of key-value tuples /// Generates a trie root hash for a vector of key-value tuples
@ -89,14 +87,15 @@ pub fn ordered_trie_root<I, A, H>(input: I) -> H::Out // TODO: return value here
/// ]; /// ];
/// ///
/// let root = "8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3"; /// let root = "8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3";
/// assert_eq!(trie_root::<_, _, _, KeccakHasher>(v), root.into()); /// assert_eq!(trie_root::<KeccakHasher, _, _, _>(v), root.into());
/// } /// }
/// ``` /// ```
pub fn trie_root<I, A, B, H>(input: I) -> H::Out pub fn trie_root<H, I, A, B>(input: I) -> H::Out
where I: IntoIterator<Item = (A, B)>, where I: IntoIterator<Item = (A, B)>,
A: AsRef<[u8]> + Ord, A: AsRef<[u8]> + Ord,
B: AsRef<[u8]>, B: AsRef<[u8]>,
H: Hasher, H: Hasher,
<H as hashdb::Hasher>::Out: cmp::Ord + rlp::Encodable,
{ {
let gen_input: Vec<_> = input let gen_input: Vec<_> = input
// first put elements into btree to sort them and to remove duplicates // first put elements into btree to sort them and to remove duplicates
@ -107,8 +106,7 @@ pub fn trie_root<I, A, B, H>(input: I) -> H::Out
.map(|(k, v)| (as_nibbles(k.as_ref()), v) ) .map(|(k, v)| (as_nibbles(k.as_ref()), v) )
.collect(); .collect();
// gen_trie_root::<H, _, _>(&gen_input) gen_trie_root::<H, _, _>(&gen_input)
gen_trie_root::<_, _, H>(&gen_input)
} }
/// Generates a key-hashed (secure) trie root hash for a vector of key-value tuples. /// Generates a key-hashed (secure) trie root hash for a vector of key-value tuples.
@ -127,42 +125,38 @@ pub fn trie_root<I, A, B, H>(input: I) -> H::Out
/// ]; /// ];
/// ///
/// let root = "d4cd937e4a4368d7931a9cf51686b7e10abb3dce38a39000fd7902a092b64585"; /// let root = "d4cd937e4a4368d7931a9cf51686b7e10abb3dce38a39000fd7902a092b64585";
/// assert_eq!(sec_trie_root::<_, _, _, KeccakHasher>(v), root.into()); /// assert_eq!(sec_trie_root::<KeccakHasher, _, _, _>(v), root.into());
/// } /// }
/// ``` /// ```
pub fn sec_trie_root<I, A, B, H>(input: I) -> H::Out pub fn sec_trie_root<H, I, A, B>(input: I) -> H::Out
where I: IntoIterator<Item = (A, B)>, where I: IntoIterator<Item = (A, B)>,
A: AsRef<[u8]>, A: AsRef<[u8]>,
B: AsRef<[u8]>, B: AsRef<[u8]>,
H: Hasher, H: Hasher,
// <H as hashdb::Hasher>::Out: std::cmp::Ord, <H as hashdb::Hasher>::Out: cmp::Ord + rlp::Encodable,
{ {
let gen_input: Vec<_> = input let gen_input: Vec<_> = input
// first put elements into btree to sort them and to remove duplicates // first put elements into btree to sort them and to remove duplicates
.into_iter() .into_iter()
.map(|(k, v)| (keccak(k), v)) // TODO: here .map(|(k, v)| (H::hash(&k.as_ref()), v))
// .map(|(k, v)| (H::hash(&k), v))
.collect::<BTreeMap<_, _>>() .collect::<BTreeMap<_, _>>()
// then move them to a vector // then move them to a vector
.into_iter() .into_iter()
.map(|(k, v)| (as_nibbles(&k), v) ) // maybe enough to .as_ref() here .map(|(k, v)| (as_nibbles(&k.as_ref()), v) )
.collect(); .collect();
// gen_trie_root::<H, _, _>(&gen_input) gen_trie_root::<H, _, _>(&gen_input)
gen_trie_root::<_, _, H>(&gen_input)
} }
// fn gen_trie_root<A: AsRef<[u8]>, B: AsRef<[u8]>>(input: &[(A, B)]) -> H256 { // TODO: here fn gen_trie_root<H, A, B>(input: &[(A, B)]) -> H::Out
fn gen_trie_root<A, B, H>(input: &[(A, B)]) -> H::Out
where where
A: AsRef<[u8]>, A: AsRef<[u8]>,
B: AsRef<[u8]>, B: AsRef<[u8]>,
H: Hasher, H: Hasher,
<H as hashdb::Hasher>::Out: cmp::Ord + rlp::Encodable,
{ {
let mut stream = RlpStream::new(); // TODO: here let mut stream = RlpStream::new();
hash256rlp(input, 0, &mut stream); // TODO: here hash256rlp::<H, _, _>(input, 0, &mut stream);
// keccak(stream.out()) // TODO: here
// <H as Hasher>::hash(&stream.out())
H::hash(&stream.out()) H::hash(&stream.out())
} }
@ -221,7 +215,13 @@ fn as_nibbles(bytes: &[u8]) -> ElasticArray8<u8> {
res res
} }
fn hash256rlp<A: AsRef<[u8]>, B: AsRef<[u8]>>(input: &[(A, B)], pre_len: usize, stream: &mut RlpStream) { fn hash256rlp<H, A, B>(input: &[(A, B)], pre_len: usize, stream: &mut RlpStream)
where
A: AsRef<[u8]>,
B: AsRef<[u8]>,
H: Hasher,
<H as hashdb::Hasher>::Out: rlp::Encodable,
{
let inlen = input.len(); let inlen = input.len();
// in case of empty slice, just append empty data // in case of empty slice, just append empty data
@ -258,7 +258,7 @@ fn hash256rlp<A: AsRef<[u8]>, B: AsRef<[u8]>>(input: &[(A, B)], pre_len: usize,
if shared_prefix > pre_len { if shared_prefix > pre_len {
stream.begin_list(2); stream.begin_list(2);
stream.append(&&*hex_prefix_encode(&key[pre_len..shared_prefix], false)); stream.append(&&*hex_prefix_encode(&key[pre_len..shared_prefix], false));
hash256aux(input, shared_prefix, stream); hash256aux::<H, _, _>(input, shared_prefix, stream);
return; return;
} }
@ -286,7 +286,7 @@ fn hash256rlp<A: AsRef<[u8]>, B: AsRef<[u8]>>(input: &[(A, B)], pre_len: usize,
// append their suffixes // append their suffixes
match len { match len {
0 => { stream.append_empty_data(); }, 0 => { stream.append_empty_data(); },
_ => hash256aux(&input[begin..(begin + len)], pre_len + 1, stream) _ => hash256aux::<H, _, _>(&input[begin..(begin + len)], pre_len + 1, stream)
} }
begin += len; begin += len;
} }
@ -298,13 +298,19 @@ fn hash256rlp<A: AsRef<[u8]>, B: AsRef<[u8]>>(input: &[(A, B)], pre_len: usize,
}; };
} }
fn hash256aux<A: AsRef<[u8]>, B: AsRef<[u8]>>(input: &[(A, B)], pre_len: usize, stream: &mut RlpStream) { fn hash256aux<H, A, B>(input: &[(A, B)], pre_len: usize, stream: &mut RlpStream)
where
A: AsRef<[u8]>,
B: AsRef<[u8]>,
H: Hasher,
<H as hashdb::Hasher>::Out: rlp::Encodable,
{
let mut s = RlpStream::new(); let mut s = RlpStream::new();
hash256rlp(input, pre_len, &mut s); hash256rlp::<H, _, _>(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),
_ => stream.append(&keccak(out)) // TODO: here _ => stream.append(&H::hash(&out))
}; };
} }
@ -360,19 +366,19 @@ mod tests {
#[test] #[test]
fn simple_test() { fn simple_test() {
assert_eq!(trie_root::<_, _, _, KeccakHasher>(vec![ assert_eq!(trie_root::<KeccakHasher, _, _, _>(vec![
(b"A", b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" as &[u8]) (b"A", b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" as &[u8])
]), "d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab".into()); ]), "d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab".into());
} }
#[test] #[test]
fn test_triehash_out_of_order() { fn test_triehash_out_of_order() {
assert!(trie_root::<_, _, _, KeccakHasher>(vec![ assert!(trie_root::<KeccakHasher, _, _, _>(vec![
(vec![0x01u8, 0x23], vec![0x01u8, 0x23]), (vec![0x01u8, 0x23], vec![0x01u8, 0x23]),
(vec![0x81u8, 0x23], vec![0x81u8, 0x23]), (vec![0x81u8, 0x23], vec![0x81u8, 0x23]),
(vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]), (vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]),
]) == ]) ==
trie_root::<_, _, _, KeccakHasher>(vec![ trie_root::<KeccakHasher, _, _, _>(vec![
(vec![0x01u8, 0x23], vec![0x01u8, 0x23]), (vec![0x01u8, 0x23], vec![0x01u8, 0x23]),
(vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]), // last two tuples are swapped (vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]), // last two tuples are swapped
(vec![0x81u8, 0x23], vec![0x81u8, 0x23]), (vec![0x81u8, 0x23], vec![0x81u8, 0x23]),