From b471d516dd32e88821ceb515e0c5052f24361428 Mon Sep 17 00:00:00 2001 From: David Palm Date: Fri, 6 Jul 2018 17:27:50 +0200 Subject: [PATCH] WIP make generic --- triehash/Cargo.toml | 4 ++- triehash/src/lib.rs | 62 ++++++++++++++++++++++++++++++++------------- 2 files changed, 47 insertions(+), 19 deletions(-) diff --git a/triehash/Cargo.toml b/triehash/Cargo.toml index 5848a7f..68b15f3 100644 --- a/triehash/Cargo.toml +++ b/triehash/Cargo.toml @@ -8,8 +8,10 @@ license = "GPL-3.0" [dependencies] elastic-array = "0.10" ethereum-types = "0.3" -rlp = { path = "../rlp" } +hashdb = { path = "../hashdb" } keccak-hash = { path = "../keccak-hash" } +rlp = { path = "../rlp" } [dev-dependencies] trie-standardmap = { path = "../trie-standardmap" } +keccak-hasher = { path = "../test-support/keccak-hasher" } \ No newline at end of file diff --git a/triehash/src/lib.rs b/triehash/src/lib.rs index b8a506e..48b00c8 100644 --- a/triehash/src/lib.rs +++ b/triehash/src/lib.rs @@ -21,13 +21,16 @@ extern crate elastic_array; extern crate ethereum_types; extern crate keccak_hash as hash; +extern crate hashdb; extern crate rlp; +#[cfg(test)] extern crate keccak_hasher; use std::collections::BTreeMap; use std::cmp; use elastic_array::{ElasticArray4, ElasticArray8}; -use ethereum_types::H256; +// use ethereum_types::H256; use hash::keccak; +use hashdb::Hasher; use rlp::RlpStream; fn shared_prefix_len(first: &[T], second: &[T]) -> usize { @@ -39,17 +42,20 @@ fn shared_prefix_len(first: &[T], second: &[T]) -> usize { /// /// ```rust /// extern crate triehash; +/// extern crate keccak_hasher; /// use triehash::ordered_trie_root; +/// use keccak_hasher::KeccakHasher; /// /// fn main() { /// let v = &["doe", "reindeer"]; /// let root = "e766d5d51b89dc39d981b41bda63248d7abce4f0225eefd023792a540bcffee3"; -/// assert_eq!(ordered_trie_root(v), root.into()); +/// assert_eq!(ordered_trie_root::<_, _, KeccakHasher>(v), root.into()); /// } /// ``` -pub fn ordered_trie_root(input: I) -> H256 // TODO: return value here +pub fn ordered_trie_root(input: I) -> H::Out // TODO: return value here where I: IntoIterator, A: AsRef<[u8]>, + H: Hasher, { let gen_input: Vec<_> = input // first put elements into btree to sort them by nibbles (key'd by index) @@ -63,15 +69,18 @@ pub fn ordered_trie_root(input: I) -> H256 // TODO: return value here .map(|(k, v)| (as_nibbles(&k), v) ) .collect(); - gen_trie_root(&gen_input) + // gen_trie_root::(&gen_input) // TODO: should be able to infer this + 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 /// /// ```rust /// extern crate triehash; +/// extern crate keccak_hasher; /// use triehash::trie_root; -/// +/// use keccak_hasher::KeccakHasher; +/// /// fn main() { /// let v = vec![ /// ("doe", "reindeer"), @@ -80,13 +89,14 @@ pub fn ordered_trie_root(input: I) -> H256 // TODO: return value here /// ]; /// /// let root = "8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3"; -/// assert_eq!(trie_root(v), root.into()); +/// assert_eq!(trie_root::<_, _, _, KeccakHasher>(v), root.into()); /// } /// ``` -pub fn trie_root(input: I) -> H256 +pub fn trie_root(input: I) -> H::Out where I: IntoIterator, A: AsRef<[u8]> + Ord, B: AsRef<[u8]>, + H: Hasher, { let gen_input: Vec<_> = input // first put elements into btree to sort them and to remove duplicates @@ -97,15 +107,18 @@ pub fn trie_root(input: I) -> H256 .map(|(k, v)| (as_nibbles(k.as_ref()), v) ) .collect(); - gen_trie_root(&gen_input) + // gen_trie_root::(&gen_input) + gen_trie_root::<_, _, H>(&gen_input) } /// Generates a key-hashed (secure) trie root hash for a vector of key-value tuples. /// /// ```rust /// extern crate triehash; +/// extern crate keccak_hasher; /// use triehash::sec_trie_root; -/// +/// use keccak_hasher::KeccakHasher; +/// /// fn main() { /// let v = vec![ /// ("doe", "reindeer"), @@ -114,31 +127,43 @@ pub fn trie_root(input: I) -> H256 /// ]; /// /// let root = "d4cd937e4a4368d7931a9cf51686b7e10abb3dce38a39000fd7902a092b64585"; -/// assert_eq!(sec_trie_root(v), root.into()); +/// assert_eq!(sec_trie_root::<_, _, _, KeccakHasher>(v), root.into()); /// } /// ``` -pub fn sec_trie_root(input: I) -> H256 +pub fn sec_trie_root(input: I) -> H::Out where I: IntoIterator, A: AsRef<[u8]>, B: AsRef<[u8]>, + H: Hasher, + // ::Out: std::cmp::Ord, { let gen_input: Vec<_> = input // first put elements into btree to sort them and to remove duplicates .into_iter() .map(|(k, v)| (keccak(k), v)) // TODO: here + // .map(|(k, v)| (H::hash(&k), v)) .collect::>() // then move them to a vector .into_iter() - .map(|(k, v)| (as_nibbles(&k), v) ) + .map(|(k, v)| (as_nibbles(&k), v) ) // maybe enough to .as_ref() here .collect(); - gen_trie_root(&gen_input) + // gen_trie_root::(&gen_input) + gen_trie_root::<_, _, H>(&gen_input) } -fn gen_trie_root, B: AsRef<[u8]>>(input: &[(A, B)]) -> H256 { // TODO: here +// fn gen_trie_root, B: AsRef<[u8]>>(input: &[(A, B)]) -> H256 { // TODO: here +fn gen_trie_root(input: &[(A, B)]) -> H::Out + where + A: AsRef<[u8]>, + B: AsRef<[u8]>, + H: Hasher, +{ let mut stream = RlpStream::new(); // TODO: here hash256rlp(input, 0, &mut stream); // TODO: here - keccak(stream.out()) // TODO: here + // keccak(stream.out()) // TODO: here + // ::hash(&stream.out()) + H::hash(&stream.out()) } /// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1. @@ -298,6 +323,7 @@ fn test_nibbles() { #[cfg(test)] mod tests { use super::{trie_root, shared_prefix_len, hex_prefix_encode}; + use keccak_hasher::KeccakHasher; #[test] fn test_hex_prefix_encode() { @@ -334,19 +360,19 @@ mod tests { #[test] fn simple_test() { - assert_eq!(trie_root(vec![ + assert_eq!(trie_root::<_, _, _, KeccakHasher>(vec![ (b"A", b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" as &[u8]) ]), "d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab".into()); } #[test] fn test_triehash_out_of_order() { - assert!(trie_root(vec![ + assert!(trie_root::<_, _, _, KeccakHasher>(vec![ (vec![0x01u8, 0x23], vec![0x01u8, 0x23]), (vec![0x81u8, 0x23], vec![0x81u8, 0x23]), (vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]), ]) == - trie_root(vec![ + trie_root::<_, _, _, KeccakHasher>(vec![ (vec![0x01u8, 0x23], vec![0x01u8, 0x23]), (vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]), // last two tuples are swapped (vec![0x81u8, 0x23], vec![0x81u8, 0x23]),