From 0e088d783d20a1dc104eaf82d600ccdc3b57885d Mon Sep 17 00:00:00 2001 From: debris Date: Wed, 30 Aug 2017 16:20:21 +0200 Subject: [PATCH] Hashable::sha3 -> fn keccak for ethcore-util --- Cargo.lock | 23 +-- ethash/Cargo.toml | 4 +- util/Cargo.toml | 2 +- util/bloomable/Cargo.toml | 2 +- util/bloomable/tests/test.rs | 24 ++-- util/{sha3 => hash}/Cargo.toml | 9 +- util/{sha3 => hash}/build.rs | 0 util/hash/src/lib.rs | 106 ++++++++++++++ util/{sha3 => hash}/src/tinykeccak.c | 24 ++-- util/sha3/src/lib.rs | 20 --- util/src/hashdb.rs | 10 +- util/src/journaldb/archivedb.rs | 95 ++++++------- util/src/journaldb/earlymergedb.rs | 187 ++++++++++++------------ util/src/journaldb/overlayrecentdb.rs | 195 +++++++++++++------------- util/src/journaldb/refcounteddb.rs | 40 +++--- util/src/lib.rs | 4 +- util/src/memorydb.rs | 19 +-- util/src/sha3.rs | 123 ---------------- util/src/trie/fatdb.rs | 10 +- util/src/trie/fatdbmut.rs | 14 +- util/src/trie/mod.rs | 3 +- util/src/trie/recorder.rs | 11 +- util/src/trie/sectriedb.rs | 8 +- util/src/trie/sectriedbmut.rs | 12 +- util/src/trie/standardmap.rs | 8 +- util/src/trie/triedbmut.rs | 29 ++-- util/src/triehash.rs | 8 +- 27 files changed, 483 insertions(+), 507 deletions(-) rename util/{sha3 => hash}/Cargo.toml (65%) rename util/{sha3 => hash}/build.rs (100%) create mode 100644 util/hash/src/lib.rs rename util/{sha3 => hash}/src/tinykeccak.c (92%) delete mode 100644 util/sha3/src/lib.rs delete mode 100644 util/src/sha3.rs diff --git a/Cargo.lock b/Cargo.lock index e2108d186..c28246791 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -196,7 +196,7 @@ name = "bloomable" version = "0.1.0" dependencies = [ "ethcore-bigint 0.1.3", - "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)", + "hash 0.1.0", ] [[package]] @@ -480,10 +480,10 @@ name = "ethash" version = "1.8.0" dependencies = [ "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", + "hash 0.1.0", "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", "parking_lot 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "primal 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", - "sha3 0.1.0", ] [[package]] @@ -777,6 +777,7 @@ dependencies = [ "ethcore-bloom-journal 0.1.0", "ethcore-devtools 1.8.0", "ethcore-logger 1.8.0", + "hash 0.1.0", "heapsize 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.21 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", @@ -789,7 +790,6 @@ dependencies = [ "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)", - "sha3 0.1.0", "target_info 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)", "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1062,6 +1062,16 @@ dependencies = [ "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "hash" +version = "0.1.0" +dependencies = [ + "ethcore-bigint 0.1.3", + "gcc 0.3.51 (registry+https://github.com/rust-lang/crates.io-index)", + "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)", + "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "heapsize" version = "0.4.0" @@ -2690,13 +2700,6 @@ name = "sha1" version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -[[package]] -name = "sha3" -version = "0.1.0" -dependencies = [ - "gcc 0.3.51 (registry+https://github.com/rust-lang/crates.io-index)", -] - [[package]] name = "shell32-sys" version = "0.1.1" diff --git a/ethash/Cargo.toml b/ethash/Cargo.toml index 87069d6f8..aa415c1f9 100644 --- a/ethash/Cargo.toml +++ b/ethash/Cargo.toml @@ -7,10 +7,10 @@ authors = ["Parity Technologies "] [dependencies] log = "0.3" -sha3 = { path = "../util/sha3" } +hash = { path = "../util/hash" } primal = "0.2.3" parking_lot = "0.4" crunchy = "0.1.0" [features] -benches = [] \ No newline at end of file +benches = [] diff --git a/util/Cargo.toml b/util/Cargo.toml index 0e485431e..d04450053 100644 --- a/util/Cargo.toml +++ b/util/Cargo.toml @@ -19,7 +19,7 @@ rust-crypto = "0.2.34" elastic-array = "0.9" rlp = { path = "rlp" } heapsize = "0.4" -sha3 = { path = "sha3" } +hash = { path = "hash" } clippy = { version = "0.0.103", optional = true} ethcore-devtools = { path = "../devtools" } libc = "0.2.7" diff --git a/util/bloomable/Cargo.toml b/util/bloomable/Cargo.toml index f85b67943..94ca4856b 100644 --- a/util/bloomable/Cargo.toml +++ b/util/bloomable/Cargo.toml @@ -7,4 +7,4 @@ authors = ["debris "] ethcore-bigint = { path = "../bigint" } [dev-dependencies] -tiny-keccak = "1.3" +hash = { path = "../hash" } diff --git a/util/bloomable/tests/test.rs b/util/bloomable/tests/test.rs index 85ced83e6..f3fa908e2 100644 --- a/util/bloomable/tests/test.rs +++ b/util/bloomable/tests/test.rs @@ -1,14 +1,10 @@ -extern crate tiny_keccak; +extern crate hash; extern crate ethcore_bigint; extern crate bloomable; use ethcore_bigint::hash::{H160, H256, H2048}; use bloomable::Bloomable; -use tiny_keccak::keccak256; - -fn sha3(input: &[u8]) -> H256 { - keccak256(input).into() -} +use hash::keccak; #[test] fn shift_bloomed() { @@ -17,15 +13,15 @@ fn shift_bloomed() { let topic: H256 = "02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc".into(); let mut my_bloom = H2048::default(); - assert!(!my_bloom.contains_bloomed(&sha3(&address))); - assert!(!my_bloom.contains_bloomed(&sha3(&topic))); + assert!(!my_bloom.contains_bloomed(&keccak(&address))); + assert!(!my_bloom.contains_bloomed(&keccak(&topic))); - my_bloom.shift_bloomed(&sha3(&address)); - assert!(my_bloom.contains_bloomed(&sha3(&address))); - assert!(!my_bloom.contains_bloomed(&sha3(&topic))); + my_bloom.shift_bloomed(&keccak(&address)); + assert!(my_bloom.contains_bloomed(&keccak(&address))); + assert!(!my_bloom.contains_bloomed(&keccak(&topic))); - my_bloom.shift_bloomed(&sha3(&topic)); + my_bloom.shift_bloomed(&keccak(&topic)); assert_eq!(my_bloom, bloom); - assert!(my_bloom.contains_bloomed(&sha3(&address))); - assert!(my_bloom.contains_bloomed(&sha3(&topic))); + assert!(my_bloom.contains_bloomed(&keccak(&address))); + assert!(my_bloom.contains_bloomed(&keccak(&topic))); } diff --git a/util/sha3/Cargo.toml b/util/hash/Cargo.toml similarity index 65% rename from util/sha3/Cargo.toml rename to util/hash/Cargo.toml index 8f8d6d160..91a195468 100644 --- a/util/sha3/Cargo.toml +++ b/util/hash/Cargo.toml @@ -2,10 +2,17 @@ description = "Rust bindings for tinykeccak C library" homepage = "http://parity.io" license = "GPL-3.0" -name = "sha3" +name = "hash" version = "0.1.0" authors = ["Parity Technologies "] build = "build.rs" +[dependencies] +ethcore-bigint = { path = "../bigint" } +tiny-keccak = "1.3" + [build-dependencies] gcc = "0.3" + +[dev-dependencies] +tempdir = "0.3" diff --git a/util/sha3/build.rs b/util/hash/build.rs similarity index 100% rename from util/sha3/build.rs rename to util/hash/build.rs diff --git a/util/hash/src/lib.rs b/util/hash/src/lib.rs new file mode 100644 index 000000000..bd0121248 --- /dev/null +++ b/util/hash/src/lib.rs @@ -0,0 +1,106 @@ +// Copyright 2015-2017 Parity Technologies (UK) Ltd. +// This file is part of Parity. + +// Parity is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Parity is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Parity. If not, see . + +extern crate ethcore_bigint as bigint; +extern crate tiny_keccak; + +use std::io; +use tiny_keccak::Keccak; +pub use bigint::hash::H256; + +/// Get the KECCAK (i.e. Keccak) hash of the empty bytes string. +pub const KECCAK_EMPTY: H256 = H256( [0xc5, 0xd2, 0x46, 0x01, 0x86, 0xf7, 0x23, 0x3c, 0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x03, 0xc0, 0xe5, 0x00, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x04, 0x5d, 0x85, 0xa4, 0x70] ); + +/// The KECCAK of the RLP encoding of empty data. +pub const KECCAK_NULL_RLP: H256 = H256( [0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21] ); + +/// The KECCAK of the RLP encoding of empty list. +pub const KECCAK_EMPTY_LIST_RLP: H256 = H256( [0x1d, 0xcc, 0x4d, 0xe8, 0xde, 0xc7, 0x5d, 0x7a, 0xab, 0x85, 0xb5, 0x67, 0xb6, 0xcc, 0xd4, 0x1a, 0xd3, 0x12, 0x45, 0x1b, 0x94, 0x8a, 0x74, 0x13, 0xf0, 0xa1, 0x42, 0xfd, 0x40, 0xd4, 0x93, 0x47] ); + +extern { + pub fn keccak_256(out: *mut u8, outlen: usize, input: *const u8, inputlen: usize) -> i32; + pub fn keccak_512(out: *mut u8, outlen: usize, input: *const u8, inputlen: usize) -> i32; +} + +pub fn keccak>(s: T) -> H256 { + let mut result = [0u8; 32]; + keccak_into(s, &mut result); + H256(result) +} + +pub fn keccak_into>(s: T, dest: &mut [u8]) { + let input = s.as_ref(); + unsafe { + keccak_256(dest.as_mut_ptr(), dest.len(), input.as_ptr(), input.len()); + } +} + +pub fn keccak_buffer(r: &mut io::BufRead) -> Result { + let mut output = [0u8; 32]; + let mut input = [0u8; 1024]; + let mut keccak = Keccak::new_keccak256(); + + // read file + loop { + let some = r.read(&mut input)?; + if some == 0 { + break; + } + keccak.update(&input[0..some]); + } + + keccak.finalize(&mut output); + Ok(output.into()) +} + +#[cfg(test)] +mod tests { + extern crate tempdir; + + use std::fs; + use std::io::{Write, BufReader}; + use self::tempdir::TempDir; + use super::{keccak, keccak_buffer, KECCAK_EMPTY}; + + #[test] + fn keccak_empty() { + assert_eq!(keccak([0u8; 0]), KECCAK_EMPTY); + } + #[test] + fn keccak_as() { + assert_eq!(keccak([0x41u8; 32]), From::from("59cad5948673622c1d64e2322488bf01619f7ff45789741b15a9f782ce9290a8")); + } + + #[test] + fn should_keccak_a_file() { + // given + let tempdir = TempDir::new("keccak").unwrap(); + let mut path = tempdir.path().to_owned(); + path.push("should_keccak_a_file"); + // Prepare file + { + let mut file = fs::File::create(&path).unwrap(); + file.write_all(b"something").unwrap(); + } + + let mut file = BufReader::new(fs::File::open(&path).unwrap()); + // when + let hash = keccak_buffer(&mut file).unwrap(); + + // then + assert_eq!(format!("{:?}", hash), "68371d7e884c168ae2022c82bd837d51837718a7f7dfb7aa3f753074a35e1d87"); + } +} diff --git a/util/sha3/src/tinykeccak.c b/util/hash/src/tinykeccak.c similarity index 92% rename from util/sha3/src/tinykeccak.c rename to util/hash/src/tinykeccak.c index 1f93ce2db..bfe172e5f 100644 --- a/util/sha3/src/tinykeccak.c +++ b/util/hash/src/tinykeccak.c @@ -13,15 +13,15 @@ #define decshake(bits) \ int shake##bits(uint8_t*, size_t, const uint8_t*, size_t); -#define decsha3(bits) \ - int sha3_##bits(uint8_t*, size_t, const uint8_t*, size_t); +#define deckeccak(bits) \ + int keccak_##bits(uint8_t*, size_t, const uint8_t*, size_t); decshake(128) decshake(256) -decsha3(224) -decsha3(256) -decsha3(384) -decsha3(512) +deckeccak(224) +deckeccak(256) +deckeccak(384) +deckeccak(512) /******** The Keccak-f[1600] permutation ********/ @@ -154,8 +154,8 @@ static inline int hash(uint8_t* out, size_t outlen, const uint8_t* in, size_t inlen) { \ return hash(out, outlen, in, inlen, 200 - (bits / 4), 0x1f); \ } -#define defsha3(bits) \ - int sha3_##bits(uint8_t* out, size_t outlen, \ +#define defkeccak(bits) \ + int keccak_##bits(uint8_t* out, size_t outlen, \ const uint8_t* in, size_t inlen) { \ if (outlen > (bits/8)) { \ return -1; \ @@ -168,10 +168,10 @@ defshake(128) defshake(256) /*** FIPS202 SHA3 FOFs ***/ -defsha3(224) -defsha3(256) -defsha3(384) -defsha3(512) +defkeccak(224) +defkeccak(256) +defkeccak(384) +defkeccak(512) diff --git a/util/sha3/src/lib.rs b/util/sha3/src/lib.rs deleted file mode 100644 index 77ecd84c3..000000000 --- a/util/sha3/src/lib.rs +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2015-2017 Parity Technologies (UK) Ltd. -// This file is part of Parity. - -// Parity is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Parity is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Parity. If not, see . - -extern { - pub fn sha3_256(out: *mut u8, outlen: usize, input: *const u8, inputlen: usize) -> i32; - pub fn sha3_512(out: *mut u8, outlen: usize, input: *const u8, inputlen: usize) -> i32; -} diff --git a/util/src/hashdb.rs b/util/src/hashdb.rs index ca4120702..3b52a2fec 100644 --- a/util/src/hashdb.rs +++ b/util/src/hashdb.rs @@ -48,14 +48,15 @@ pub trait HashDB: AsHashDB + Send + Sync { /// /// # Examples /// ```rust + /// extern crate hash; /// extern crate ethcore_util; /// use ethcore_util::hashdb::*; /// use ethcore_util::memorydb::*; - /// use ethcore_util::sha3::*; + /// use hash::keccak; /// fn main() { /// let mut m = MemoryDB::new(); /// let hello_bytes = "Hello world!".as_bytes(); - /// assert!(!m.contains(&hello_bytes.sha3())); + /// assert!(!m.contains(&keccak(hello_bytes))); /// let key = m.insert(hello_bytes); /// assert!(m.contains(&key)); /// m.remove(&key); @@ -91,13 +92,14 @@ pub trait HashDB: AsHashDB + Send + Sync { /// # Examples /// ```rust /// extern crate ethcore_util; + /// extern crate hash; /// use ethcore_util::hashdb::*; /// use ethcore_util::memorydb::*; - /// use ethcore_util::sha3::*; + /// use hash::keccak; /// fn main() { /// let mut m = MemoryDB::new(); /// let d = "Hello world!".as_bytes(); - /// let key = &d.sha3(); + /// let key = &keccak(d); /// m.remove(key); // OK - we now owe an insertion. /// assert!(!m.contains(key)); /// m.remove(key); // OK - we now owe two insertions. diff --git a/util/src/journaldb/archivedb.rs b/util/src/journaldb/archivedb.rs index 8c87ef623..3f4b948f3 100644 --- a/util/src/journaldb/archivedb.rs +++ b/util/src/journaldb/archivedb.rs @@ -205,11 +205,12 @@ mod tests { #![cfg_attr(feature="dev", allow(similar_names))] use std::path::Path; + use keccak::keccak; use hashdb::{HashDB, DBValue}; use super::*; use journaldb::traits::JournalDB; use kvdb::Database; - use {Hashable, H32}; + use {H32}; #[test] fn insert_same_in_fork() { @@ -217,18 +218,18 @@ mod tests { let mut jdb = ArchiveDB::new_temp(); let x = jdb.insert(b"X"); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); - jdb.commit_batch(3, &b"1002a".sha3(), Some((1, b"1".sha3()))).unwrap(); - jdb.commit_batch(4, &b"1003a".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); + jdb.commit_batch(3, &keccak(b"1002a"), Some((1, keccak(b"1")))).unwrap(); + jdb.commit_batch(4, &keccak(b"1003a"), Some((2, keccak(b"2")))).unwrap(); jdb.remove(&x); - jdb.commit_batch(3, &b"1002b".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"1002b"), Some((1, keccak(b"1")))).unwrap(); let x = jdb.insert(b"X"); - jdb.commit_batch(4, &b"1003b".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"1003b"), Some((2, keccak(b"2")))).unwrap(); - jdb.commit_batch(5, &b"1004a".sha3(), Some((3, b"1002a".sha3()))).unwrap(); - jdb.commit_batch(6, &b"1005a".sha3(), Some((4, b"1003a".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"1004a"), Some((3, keccak(b"1002a")))).unwrap(); + jdb.commit_batch(6, &keccak(b"1005a"), Some((4, keccak(b"1003a")))).unwrap(); assert!(jdb.contains(&x)); } @@ -238,16 +239,16 @@ mod tests { // history is 3 let mut jdb = ArchiveDB::new_temp(); let h = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&h)); jdb.remove(&h); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.contains(&h)); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.contains(&h)); - jdb.commit_batch(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.contains(&h)); - jdb.commit_batch(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.contains(&h)); } @@ -256,13 +257,13 @@ mod tests { fn multiple_owed_removal_not_allowed() { let mut jdb = ArchiveDB::new_temp(); let h = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&h)); jdb.remove(&h); jdb.remove(&h); // commit_batch would call journal_under(), // and we don't allow multiple owned removals. - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); } #[test] @@ -272,29 +273,29 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); jdb.remove(&foo); jdb.remove(&bar); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); assert!(jdb.contains(&baz)); let foo = jdb.insert(b"foo"); jdb.remove(&baz); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&baz)); jdb.remove(&foo); - jdb.commit_batch(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.contains(&foo)); - jdb.commit_batch(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((3, keccak(b"3")))).unwrap(); } #[test] @@ -304,22 +305,22 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); jdb.remove(&foo); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); jdb.remove(&bar); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); assert!(jdb.contains(&baz)); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.contains(&foo)); } @@ -329,16 +330,16 @@ mod tests { let mut jdb = ArchiveDB::new_temp(); let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&foo)); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); jdb.insert(b"foo"); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.contains(&foo)); - jdb.commit_batch(3, &b"2".sha3(), Some((0, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"2"), Some((0, keccak(b"2")))).unwrap(); assert!(jdb.contains(&foo)); } @@ -346,16 +347,16 @@ mod tests { fn fork_same_key() { // history is 1 let mut jdb = ArchiveDB::new_temp(); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2a".sha3(), Some((1, b"1a".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2a"), Some((1, keccak(b"1a")))).unwrap(); assert!(jdb.contains(&foo)); } @@ -375,21 +376,21 @@ mod tests { // history is 1 let foo = jdb.insert(b"foo"); jdb.emplace(bar.clone(), DBValue::from_slice(b"bar")); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); foo }; { let mut jdb = new_db(&dir); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); } { let mut jdb = new_db(&dir); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); } } @@ -402,24 +403,24 @@ mod tests { let mut jdb = new_db(&dir); // history is 1 let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); // foo is ancient history. jdb.insert(b"foo"); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); foo }; { let mut jdb = new_db(&dir); jdb.remove(&foo); - jdb.commit_batch(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.contains(&foo)); jdb.remove(&foo); - jdb.commit_batch(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap(); - jdb.commit_batch(5, &b"5".sha3(), Some((4, b"4".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((3, keccak(b"3")))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((4, keccak(b"4")))).unwrap(); } } @@ -432,19 +433,19 @@ mod tests { // history is 1 let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); jdb.remove(&foo); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); jdb.remove(&bar); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); (foo, bar, baz) }; { let mut jdb = new_db(&dir); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.contains(&foo)); } } @@ -456,7 +457,7 @@ mod tests { let key = { let mut jdb = new_db(temp.as_path().as_path()); let key = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); key }; diff --git a/util/src/journaldb/earlymergedb.rs b/util/src/journaldb/earlymergedb.rs index 0d0681a03..dce7660f8 100644 --- a/util/src/journaldb/earlymergedb.rs +++ b/util/src/journaldb/earlymergedb.rs @@ -577,12 +577,13 @@ mod tests { #![cfg_attr(feature="dev", allow(similar_names))] use std::path::Path; + use keccak::keccak; use hashdb::{HashDB, DBValue}; use super::*; use super::super::traits::JournalDB; use ethcore_logger::init_log; use kvdb::{DatabaseConfig}; - use {Hashable, H32}; + use {H32}; #[test] fn insert_same_in_fork() { @@ -590,25 +591,25 @@ mod tests { let mut jdb = EarlyMergeDB::new_temp(); let x = jdb.insert(b"X"); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(3, &b"1002a".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"1002a"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(4, &b"1003a".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"1003a"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&x); - jdb.commit_batch(3, &b"1002b".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"1002b"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); let x = jdb.insert(b"X"); - jdb.commit_batch(4, &b"1003b".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"1003b"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(5, &b"1004a".sha3(), Some((3, b"1002a".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"1004a"), Some((3, keccak(b"1002a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(6, &b"1005a".sha3(), Some((4, b"1003a".sha3()))).unwrap(); + jdb.commit_batch(6, &keccak(b"1005a"), Some((4, keccak(b"1003a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&x)); @@ -618,17 +619,17 @@ mod tests { fn insert_older_era() { let mut jdb = EarlyMergeDB::new_temp(); let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0a".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let bar = jdb.insert(b"bar"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0a".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&bar); - jdb.commit_batch(0, &b"0b".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); @@ -639,20 +640,20 @@ mod tests { // history is 3 let mut jdb = EarlyMergeDB::new_temp(); let h = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); jdb.remove(&h); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); - jdb.commit_batch(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); - jdb.commit_batch(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&h)); } @@ -664,7 +665,7 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); @@ -672,7 +673,7 @@ mod tests { jdb.remove(&foo); jdb.remove(&bar); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); @@ -680,20 +681,20 @@ mod tests { let foo = jdb.insert(b"foo"); jdb.remove(&baz); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&bar)); assert!(jdb.contains(&baz)); jdb.remove(&foo); - jdb.commit_batch(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&bar)); assert!(!jdb.contains(&baz)); - jdb.commit_batch(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); assert!(!jdb.contains(&bar)); @@ -707,25 +708,25 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); jdb.remove(&foo); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&bar); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); assert!(jdb.contains(&baz)); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&baz)); @@ -738,19 +739,19 @@ mod tests { let mut jdb = EarlyMergeDB::new_temp(); let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); - jdb.commit_batch(3, &b"2".sha3(), Some((0, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"2"), Some((0, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); } @@ -759,24 +760,24 @@ mod tests { fn fork_same_key_one() { let mut jdb = EarlyMergeDB::new_temp(); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1c"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2a".sha3(), Some((1, b"1a".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2a"), Some((1, keccak(b"1a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); } @@ -784,24 +785,24 @@ mod tests { #[test] fn fork_same_key_other() { let mut jdb = EarlyMergeDB::new_temp(); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1c"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); } @@ -809,33 +810,33 @@ mod tests { #[test] fn fork_ins_del_ins() { let mut jdb = EarlyMergeDB::new_temp(); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(2, &b"2a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(2, &b"2b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3a".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3a"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3b".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3b"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(4, &b"4a".sha3(), Some((2, b"2a".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4a"), Some((2, keccak(b"2a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(5, &b"5a".sha3(), Some((3, b"3a".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5a"), Some((3, keccak(b"3a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -856,7 +857,7 @@ mod tests { // history is 1 let foo = jdb.insert(b"foo"); jdb.emplace(bar.clone(), DBValue::from_slice(b"bar")); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); foo }; @@ -864,7 +865,7 @@ mod tests { { let mut jdb = new_db(&dir); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -872,7 +873,7 @@ mod tests { let mut jdb = new_db(&dir); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); } @@ -886,22 +887,22 @@ mod tests { // history is 4 let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(3, &b"3".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(4, &b"4".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // expunge foo - jdb.commit_batch(5, &b"5".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -912,43 +913,43 @@ mod tests { // history is 4 let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(1, &b"1a".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(1, &b"1b".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(2, &b"2a".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(2, &b"2b".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(3, &b"3a".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(3, &b"3b".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(4, &b"4a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(4, &b"4b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // expunge foo - jdb.commit_batch(5, &b"5".sha3(), Some((1, b"1a".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((1, keccak(b"1a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -958,25 +959,25 @@ mod tests { // history is 1 let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // foo is ancient history. jdb.remove(&foo); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap(); // BROKEN + jdb.commit_batch(3, &keccak(b"3"), Some((2, keccak(b"2")))).unwrap(); // BROKEN assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); jdb.remove(&foo); - jdb.commit_batch(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(5, &b"5".sha3(), Some((4, b"4".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((4, keccak(b"4")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); } @@ -987,30 +988,30 @@ mod tests { // history is 4 let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(3, &b"3".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(4, &b"4".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // foo is ancient history. jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(5, &b"5".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); jdb.remove(&bar); - jdb.commit_batch(6, &b"6".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(6, &keccak(b"6"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); jdb.insert(b"bar"); - jdb.commit_batch(7, &b"7".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(7, &keccak(b"7"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -1021,26 +1022,26 @@ mod tests { let mut dir = ::std::env::temp_dir(); dir.push(H32::random().hex()); - let foo = b"foo".sha3(); + let foo = keccak(b"foo"); { let mut jdb = new_db(&dir); // history is 1 jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); // foo is ancient history. jdb.remove(&foo); - jdb.commit_batch(2, &b"2".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); @@ -1049,7 +1050,7 @@ mod tests { let mut jdb = new_db(&dir); jdb.remove(&foo); - jdb.commit_batch(4, &b"4".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); @@ -1057,7 +1058,7 @@ mod tests { }; { let mut jdb = new_db(&dir); - jdb.commit_batch(5, &b"5".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); @@ -1065,7 +1066,7 @@ mod tests { }; { let mut jdb = new_db(&dir); - jdb.commit_batch(6, &b"6".sha3(), Some((4, b"4".sha3()))).unwrap(); + jdb.commit_batch(6, &keccak(b"6"), Some((4, keccak(b"4")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); } @@ -1080,22 +1081,22 @@ mod tests { // history is 1 let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&bar); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); (foo, bar, baz) }; { let mut jdb = new_db(&dir); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&baz)); diff --git a/util/src/journaldb/overlayrecentdb.rs b/util/src/journaldb/overlayrecentdb.rs index 975abd8e8..d2f6cc741 100644 --- a/util/src/journaldb/overlayrecentdb.rs +++ b/util/src/journaldb/overlayrecentdb.rs @@ -461,12 +461,13 @@ mod tests { #![cfg_attr(feature="dev", allow(similar_names))] use std::path::Path; + use keccak::keccak; use super::*; use hashdb::{HashDB, DBValue}; use ethcore_logger::init_log; use journaldb::JournalDB; use kvdb::Database; - use {H32, Hashable}; + use {H32}; fn new_db(path: &Path) -> OverlayRecentDB { let backing = Arc::new(Database::open_default(path.to_str().unwrap()).unwrap()); @@ -479,25 +480,25 @@ mod tests { let mut jdb = OverlayRecentDB::new_temp(); let x = jdb.insert(b"X"); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(3, &b"1002a".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"1002a"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(4, &b"1003a".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"1003a"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&x); - jdb.commit_batch(3, &b"1002b".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"1002b"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); let x = jdb.insert(b"X"); - jdb.commit_batch(4, &b"1003b".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"1003b"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(5, &b"1004a".sha3(), Some((3, b"1002a".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"1004a"), Some((3, keccak(b"1002a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(6, &b"1005a".sha3(), Some((4, b"1003a".sha3()))).unwrap(); + jdb.commit_batch(6, &keccak(b"1005a"), Some((4, keccak(b"1003a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&x)); @@ -508,20 +509,20 @@ mod tests { // history is 3 let mut jdb = OverlayRecentDB::new_temp(); let h = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); jdb.remove(&h); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); - jdb.commit_batch(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&h)); - jdb.commit_batch(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&h)); } @@ -533,7 +534,7 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); @@ -541,7 +542,7 @@ mod tests { jdb.remove(&foo); jdb.remove(&bar); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); @@ -549,20 +550,20 @@ mod tests { let foo = jdb.insert(b"foo"); jdb.remove(&baz); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&bar)); assert!(jdb.contains(&baz)); jdb.remove(&foo); - jdb.commit_batch(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&bar)); assert!(!jdb.contains(&baz)); - jdb.commit_batch(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); assert!(!jdb.contains(&bar)); @@ -576,25 +577,25 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); jdb.remove(&foo); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&bar); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); assert!(jdb.contains(&baz)); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&baz)); @@ -607,19 +608,19 @@ mod tests { let mut jdb = OverlayRecentDB::new_temp(); let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); - jdb.commit_batch(3, &b"2".sha3(), Some((0, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"2"), Some((0, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); } @@ -627,24 +628,24 @@ mod tests { #[test] fn fork_same_key_one() { let mut jdb = OverlayRecentDB::new_temp(); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1c"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2a".sha3(), Some((1, b"1a".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2a"), Some((1, keccak(b"1a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); } @@ -653,24 +654,24 @@ mod tests { fn fork_same_key_other() { let mut jdb = OverlayRecentDB::new_temp(); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1c"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); } @@ -679,33 +680,33 @@ mod tests { fn fork_ins_del_ins() { let mut jdb = OverlayRecentDB::new_temp(); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(2, &b"2a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(2, &b"2b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3a".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3a"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3b".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3b"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(4, &b"4a".sha3(), Some((2, b"2a".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4a"), Some((2, keccak(b"2a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(5, &b"5a".sha3(), Some((3, b"3a".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5a"), Some((3, keccak(b"3a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -720,7 +721,7 @@ mod tests { // history is 1 let foo = jdb.insert(b"foo"); jdb.emplace(bar.clone(), DBValue::from_slice(b"bar")); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); foo }; @@ -728,7 +729,7 @@ mod tests { { let mut jdb = new_db(&dir); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -736,7 +737,7 @@ mod tests { let mut jdb = new_db(&dir); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); } @@ -749,22 +750,22 @@ mod tests { // history is 4 let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(3, &b"3".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(4, &b"4".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // expunge foo - jdb.commit_batch(5, &b"5".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -775,43 +776,43 @@ mod tests { // history is 4 let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(1, &b"1a".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(1, &b"1b".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(2, &b"2a".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(2, &b"2b".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(3, &b"3a".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); - jdb.commit_batch(3, &b"3b".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(4, &b"4a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(4, &b"4b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // expunge foo - jdb.commit_batch(5, &b"5".sha3(), Some((1, b"1a".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((1, keccak(b"1a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -820,25 +821,25 @@ mod tests { let mut jdb = OverlayRecentDB::new_temp(); let foo = jdb.insert(b"foo"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // foo is ancient history. jdb.remove(&foo); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap(); // BROKEN + jdb.commit_batch(3, &keccak(b"3"), Some((2, keccak(b"2")))).unwrap(); // BROKEN assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); jdb.remove(&foo); - jdb.commit_batch(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(5, &b"5".sha3(), Some((4, b"4".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((4, keccak(b"4")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); } @@ -848,30 +849,30 @@ mod tests { let mut jdb = OverlayRecentDB::new_temp(); // history is 4 let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(3, &b"3".sha3(), None).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(4, &b"4".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); // foo is ancient history. jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(5, &b"5".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); jdb.remove(&bar); - jdb.commit_batch(6, &b"6".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(6, &keccak(b"6"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.insert(b"foo"); jdb.insert(b"bar"); - jdb.commit_batch(7, &b"7".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(7, &keccak(b"7"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); } @@ -882,26 +883,26 @@ mod tests { let mut dir = ::std::env::temp_dir(); dir.push(H32::random().hex()); - let foo = b"foo".sha3(); + let foo = keccak(b"foo"); { let mut jdb = new_db(&dir); // history is 1 jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); // foo is ancient history. jdb.remove(&foo); - jdb.commit_batch(2, &b"2".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); jdb.insert(b"foo"); - jdb.commit_batch(3, &b"3".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); @@ -910,7 +911,7 @@ mod tests { let mut jdb = new_db(&dir); jdb.remove(&foo); - jdb.commit_batch(4, &b"4".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); @@ -918,7 +919,7 @@ mod tests { }; { let mut jdb = new_db(&dir); - jdb.commit_batch(5, &b"5".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(5, &keccak(b"5"), Some((3, keccak(b"3")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); @@ -926,7 +927,7 @@ mod tests { }; { let mut jdb = new_db(&dir); - jdb.commit_batch(6, &b"6".sha3(), Some((4, b"4".sha3()))).unwrap(); + jdb.commit_batch(6, &keccak(b"6"), Some((4, keccak(b"4")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(!jdb.contains(&foo)); } @@ -941,22 +942,22 @@ mod tests { // history is 1 let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&foo); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&bar); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.can_reconstruct_refs()); (foo, bar, baz) }; { let mut jdb = new_db(&dir); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.can_reconstruct_refs()); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&baz)); @@ -968,17 +969,17 @@ mod tests { fn insert_older_era() { let mut jdb = OverlayRecentDB::new_temp(); let foo = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0a".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0a"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); let bar = jdb.insert(b"bar"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0a".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0a")))).unwrap(); assert!(jdb.can_reconstruct_refs()); jdb.remove(&bar); - jdb.commit_batch(0, &b"0b".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0b"), None).unwrap(); assert!(jdb.can_reconstruct_refs()); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); @@ -1010,28 +1011,28 @@ mod tests { // single journalled era. let _key = jdb.insert(b"hello!"); let mut batch = jdb.backing().transaction(); - jdb.journal_under(&mut batch, 0, &b"0".sha3()).unwrap(); + jdb.journal_under(&mut batch, 0, &keccak(b"0")).unwrap(); jdb.backing().write_buffered(batch); assert_eq!(jdb.earliest_era(), Some(0)); // second journalled era. let mut batch = jdb.backing().transaction(); - jdb.journal_under(&mut batch, 1, &b"1".sha3()).unwrap(); + jdb.journal_under(&mut batch, 1, &keccak(b"1")).unwrap(); jdb.backing().write_buffered(batch); assert_eq!(jdb.earliest_era(), Some(0)); // single journalled era. let mut batch = jdb.backing().transaction(); - jdb.mark_canonical(&mut batch, 0, &b"0".sha3()).unwrap(); + jdb.mark_canonical(&mut batch, 0, &keccak(b"0")).unwrap(); jdb.backing().write_buffered(batch); assert_eq!(jdb.earliest_era(), Some(1)); // no journalled eras. let mut batch = jdb.backing().transaction(); - jdb.mark_canonical(&mut batch, 1, &b"1".sha3()).unwrap(); + jdb.mark_canonical(&mut batch, 1, &keccak(b"1")).unwrap(); jdb.backing().write_buffered(batch); assert_eq!(jdb.earliest_era(), Some(1)); diff --git a/util/src/journaldb/refcounteddb.rs b/util/src/journaldb/refcounteddb.rs index 1b9c9ded8..d0990b125 100644 --- a/util/src/journaldb/refcounteddb.rs +++ b/util/src/journaldb/refcounteddb.rs @@ -213,26 +213,26 @@ mod tests { #![cfg_attr(feature="dev", allow(blacklisted_name))] #![cfg_attr(feature="dev", allow(similar_names))] + use keccak::keccak; use hashdb::{HashDB, DBValue}; use super::*; use super::super::traits::JournalDB; - use {Hashable}; #[test] fn long_history() { // history is 3 let mut jdb = RefCountedDB::new_temp(); let h = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&h)); jdb.remove(&h); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert!(jdb.contains(&h)); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert!(jdb.contains(&h)); - jdb.commit_batch(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.contains(&h)); - jdb.commit_batch(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((1, keccak(b"1")))).unwrap(); assert!(!jdb.contains(&h)); } @@ -242,16 +242,16 @@ mod tests { let mut jdb = RefCountedDB::new_temp(); assert_eq!(jdb.latest_era(), None); let h = jdb.insert(b"foo"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert_eq!(jdb.latest_era(), Some(0)); jdb.remove(&h); - jdb.commit_batch(1, &b"1".sha3(), None).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), None).unwrap(); assert_eq!(jdb.latest_era(), Some(1)); - jdb.commit_batch(2, &b"2".sha3(), None).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), None).unwrap(); assert_eq!(jdb.latest_era(), Some(2)); - jdb.commit_batch(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((0, keccak(b"0")))).unwrap(); assert_eq!(jdb.latest_era(), Some(3)); - jdb.commit_batch(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((1, keccak(b"1")))).unwrap(); assert_eq!(jdb.latest_era(), Some(4)); } @@ -262,32 +262,32 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); jdb.remove(&foo); jdb.remove(&bar); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); assert!(jdb.contains(&baz)); let foo = jdb.insert(b"foo"); jdb.remove(&baz); - jdb.commit_batch(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2"), Some((1, keccak(b"1")))).unwrap(); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&bar)); assert!(jdb.contains(&baz)); jdb.remove(&foo); - jdb.commit_batch(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap(); + jdb.commit_batch(3, &keccak(b"3"), Some((2, keccak(b"2")))).unwrap(); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&bar)); assert!(!jdb.contains(&baz)); - jdb.commit_batch(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap(); + jdb.commit_batch(4, &keccak(b"4"), Some((3, keccak(b"3")))).unwrap(); assert!(!jdb.contains(&foo)); assert!(!jdb.contains(&bar)); assert!(!jdb.contains(&baz)); @@ -300,22 +300,22 @@ mod tests { let foo = jdb.insert(b"foo"); let bar = jdb.insert(b"bar"); - jdb.commit_batch(0, &b"0".sha3(), None).unwrap(); + jdb.commit_batch(0, &keccak(b"0"), None).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); jdb.remove(&foo); let baz = jdb.insert(b"baz"); - jdb.commit_batch(1, &b"1a".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1a"), Some((0, keccak(b"0")))).unwrap(); jdb.remove(&bar); - jdb.commit_batch(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.commit_batch(1, &keccak(b"1b"), Some((0, keccak(b"0")))).unwrap(); assert!(jdb.contains(&foo)); assert!(jdb.contains(&bar)); assert!(jdb.contains(&baz)); - jdb.commit_batch(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap(); + jdb.commit_batch(2, &keccak(b"2b"), Some((1, keccak(b"1b")))).unwrap(); assert!(jdb.contains(&foo)); assert!(!jdb.contains(&baz)); assert!(!jdb.contains(&bar)); diff --git a/util/src/lib.rs b/util/src/lib.rs index 46730fe9c..def0b17c8 100644 --- a/util/src/lib.rs +++ b/util/src/lib.rs @@ -107,6 +107,7 @@ extern crate regex; extern crate lru_cache; extern crate heapsize; extern crate ethcore_logger; +extern crate hash as keccak; #[macro_use] extern crate log as rlog; @@ -117,7 +118,7 @@ pub mod error; pub mod bytes; pub mod misc; pub mod vector; -pub mod sha3; +//pub mod sha3; pub mod hashdb; pub mod memorydb; pub mod migration; @@ -146,7 +147,6 @@ pub use timer::*; pub use error::*; pub use bytes::*; pub use vector::*; -pub use sha3::*; pub use bigint::prelude::*; pub use bigint::hash; diff --git a/util/src/memorydb.rs b/util/src/memorydb.rs index 6c9cb63fe..b3a951569 100644 --- a/util/src/memorydb.rs +++ b/util/src/memorydb.rs @@ -22,7 +22,7 @@ use std::collections::hash_map::Entry; use heapsize::HeapSizeOf; use hash::{H256FastMap, H256}; use rlp::NULL_RLP; -use sha3::*; +use keccak::{KECCAK_NULL_RLP, keccak}; use hashdb::*; /// Reference-counted memory-based `HashDB` implementation. @@ -117,7 +117,7 @@ impl MemoryDB { /// Even when Some is returned, the data is only guaranteed to be useful /// when the refs > 0. pub fn raw(&self, key: &H256) -> Option<(DBValue, i32)> { - if key == &SHA3_NULL_RLP { + if key == &KECCAK_NULL_RLP { return Some((DBValue::from_slice(&NULL_RLP), 1)); } self.data.get(key).cloned() @@ -131,7 +131,7 @@ impl MemoryDB { /// Remove an element and delete it from storage if reference count reaches zero. /// If the value was purged, return the old value. pub fn remove_and_purge(&mut self, key: &H256) -> Option { - if key == &SHA3_NULL_RLP { + if key == &KECCAK_NULL_RLP { return None; } match self.data.entry(key.clone()) { @@ -170,7 +170,7 @@ impl MemoryDB { impl HashDB for MemoryDB { fn get(&self, key: &H256) -> Option { - if key == &SHA3_NULL_RLP { + if key == &KECCAK_NULL_RLP { return Some(DBValue::from_slice(&NULL_RLP)); } @@ -191,7 +191,7 @@ impl HashDB for MemoryDB { } fn contains(&self, key: &H256) -> bool { - if key == &SHA3_NULL_RLP { + if key == &KECCAK_NULL_RLP { return true; } @@ -203,9 +203,9 @@ impl HashDB for MemoryDB { fn insert(&mut self, value: &[u8]) -> H256 { if value == &NULL_RLP { - return SHA3_NULL_RLP.clone(); + return KECCAK_NULL_RLP.clone(); } - let key = value.sha3(); + let key = keccak(value); match self.data.entry(key) { Entry::Occupied(mut entry) => { let &mut (ref mut old_value, ref mut rc) = entry.get_mut(); @@ -241,7 +241,7 @@ impl HashDB for MemoryDB { } fn remove(&mut self, key: &H256) { - if key == &SHA3_NULL_RLP { + if key == &KECCAK_NULL_RLP { return; } @@ -259,12 +259,13 @@ impl HashDB for MemoryDB { #[cfg(test)] mod tests { + use keccak::keccak; use super::*; #[test] fn memorydb_remove_and_purge() { let hello_bytes = b"Hello world!"; - let hello_key = hello_bytes.sha3(); + let hello_key = keccak(hello_bytes); let mut m = MemoryDB::new(); m.remove(&hello_key); diff --git a/util/src/sha3.rs b/util/src/sha3.rs deleted file mode 100644 index 8adcfbfee..000000000 --- a/util/src/sha3.rs +++ /dev/null @@ -1,123 +0,0 @@ -// Copyright 2015-2017 Parity Technologies (UK) Ltd. -// This file is part of Parity. - -// Parity is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Parity is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Parity. If not, see . - -//! Wrapper around tiny-keccak crate as well as common hash constants. -extern crate sha3 as sha3_ext; - -use std::io; -use tiny_keccak::Keccak; -use hash::H256; -use self::sha3_ext::*; - -/// Get the SHA3 (i.e. Keccak) hash of the empty bytes string. -pub const SHA3_EMPTY: H256 = H256( [0xc5, 0xd2, 0x46, 0x01, 0x86, 0xf7, 0x23, 0x3c, 0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x03, 0xc0, 0xe5, 0x00, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x04, 0x5d, 0x85, 0xa4, 0x70] ); - -/// The SHA3 of the RLP encoding of empty data. -pub const SHA3_NULL_RLP: H256 = H256( [0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21] ); - -/// The SHA3 of the RLP encoding of empty list. -pub const SHA3_EMPTY_LIST_RLP: H256 = H256( [0x1d, 0xcc, 0x4d, 0xe8, 0xde, 0xc7, 0x5d, 0x7a, 0xab, 0x85, 0xb5, 0x67, 0xb6, 0xcc, 0xd4, 0x1a, 0xd3, 0x12, 0x45, 0x1b, 0x94, 0x8a, 0x74, 0x13, 0xf0, 0xa1, 0x42, 0xfd, 0x40, 0xd4, 0x93, 0x47] ); - -/// Types implementing this trait are sha3able. -/// -/// ``` -/// extern crate ethcore_util as util; -/// use std::str::FromStr; -/// use util::sha3::*; -/// use util::hash::*; -/// -/// fn main() { -/// assert_eq!([0u8; 0].sha3(), H256::from_str("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").unwrap()); -/// } -/// ``` -pub trait Hashable { - /// Calculate SHA3 of this object. - fn sha3(&self) -> H256; - - /// Calculate SHA3 of this object and place result into dest. - fn sha3_into(&self, dest: &mut [u8]) { - self.sha3().copy_to(dest); - } -} - -impl Hashable for T where T: AsRef<[u8]> { - fn sha3(&self) -> H256 { - let mut ret: H256 = H256::zero(); - self.sha3_into(&mut *ret); - ret - } - fn sha3_into(&self, dest: &mut [u8]) { - let input: &[u8] = self.as_ref(); - - unsafe { - sha3_256(dest.as_mut_ptr(), dest.len(), input.as_ptr(), input.len()); - } - } -} - -/// Calculate SHA3 of given stream. -pub fn sha3(r: &mut io::BufRead) -> Result { - let mut output = [0u8; 32]; - let mut input = [0u8; 1024]; - let mut sha3 = Keccak::new_keccak256(); - - // read file - loop { - let some = r.read(&mut input)?; - if some == 0 { - break; - } - sha3.update(&input[0..some]); - } - - sha3.finalize(&mut output); - Ok(output.into()) -} - -#[cfg(test)] -mod tests { - use std::fs; - use std::io::{Write, BufReader}; - use super::*; - - #[test] - fn sha3_empty() { - assert_eq!([0u8; 0].sha3(), SHA3_EMPTY); - } - #[test] - fn sha3_as() { - assert_eq!([0x41u8; 32].sha3(), From::from("59cad5948673622c1d64e2322488bf01619f7ff45789741b15a9f782ce9290a8")); - } - - #[test] - fn should_sha3_a_file() { - // given - use devtools::RandomTempPath; - let path = RandomTempPath::new(); - // Prepare file - { - let mut file = fs::File::create(&path).unwrap(); - file.write_all(b"something").unwrap(); - } - - let mut file = BufReader::new(fs::File::open(&path).unwrap()); - // when - let hash = sha3(&mut file).unwrap(); - - // then - assert_eq!(format!("{:?}", hash), "68371d7e884c168ae2022c82bd837d51837718a7f7dfb7aa3f753074a35e1d87"); - } -} diff --git a/util/src/trie/fatdb.rs b/util/src/trie/fatdb.rs index f10e6d4bf..0ea5d2d65 100644 --- a/util/src/trie/fatdb.rs +++ b/util/src/trie/fatdb.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use hash::H256; -use sha3::Hashable; +use keccak::keccak; use hashdb::HashDB; use super::{TrieDB, Trie, TrieDBIterator, TrieItem, TrieIterator, Query}; @@ -55,13 +55,13 @@ impl<'db> Trie for FatDB<'db> { } fn contains(&self, key: &[u8]) -> super::Result { - self.raw.contains(&key.sha3()) + self.raw.contains(&keccak(key)) } fn get_with<'a, 'key, Q: Query>(&'a self, key: &'key [u8], query: Q) -> super::Result> where 'a: 'key { - self.raw.get_with(&key.sha3(), query) + self.raw.get_with(&keccak(key), query) } } @@ -83,7 +83,7 @@ impl<'db> FatDBIterator<'db> { impl<'db> TrieIterator for FatDBIterator<'db> { fn seek(&mut self, key: &[u8]) -> super::Result<()> { - self.trie_iterator.seek(&key.sha3()) + self.trie_iterator.seek(&keccak(key)) } } @@ -94,7 +94,7 @@ impl<'db> Iterator for FatDBIterator<'db> { self.trie_iterator.next() .map(|res| res.map(|(hash, value)| { - let aux_hash = hash.sha3(); + let aux_hash = keccak(hash); (self.trie.db().get(&aux_hash).expect("Missing fatdb hash").into_vec(), value) }) ) diff --git a/util/src/trie/fatdbmut.rs b/util/src/trie/fatdbmut.rs index 0f5d6f47e..ebbcc92db 100644 --- a/util/src/trie/fatdbmut.rs +++ b/util/src/trie/fatdbmut.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use hash::H256; -use sha3::Hashable; +use keccak::keccak; use hashdb::{HashDB, DBValue}; use super::{TrieDBMut, TrieMut}; @@ -53,7 +53,7 @@ impl<'db> FatDBMut<'db> { } fn to_aux_key(key: &[u8]) -> H256 { - key.sha3() + keccak(key) } } @@ -67,17 +67,17 @@ impl<'db> TrieMut for FatDBMut<'db> { } fn contains(&self, key: &[u8]) -> super::Result { - self.raw.contains(&key.sha3()) + self.raw.contains(&keccak(key)) } fn get<'a, 'key>(&'a self, key: &'key [u8]) -> super::Result> where 'a: 'key { - self.raw.get(&key.sha3()) + self.raw.get(&keccak(key)) } fn insert(&mut self, key: &[u8], value: &[u8]) -> super::Result> { - let hash = key.sha3(); + let hash = keccak(key); let out = self.raw.insert(&hash, value)?; let db = self.raw.db_mut(); @@ -89,7 +89,7 @@ impl<'db> TrieMut for FatDBMut<'db> { } fn remove(&mut self, key: &[u8]) -> super::Result> { - let hash = key.sha3(); + let hash = keccak(key); let out = self.raw.remove(&hash)?; // don't remove if it already exists. @@ -114,5 +114,5 @@ fn fatdb_to_trie() { t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]).unwrap(); } let t = TrieDB::new(&memdb, &root).unwrap(); - assert_eq!(t.get(&(&[0x01u8, 0x23]).sha3()).unwrap().unwrap(), DBValue::from_slice(&[0x01u8, 0x23])); + assert_eq!(t.get(&keccak(&[0x01u8, 0x23])).unwrap().unwrap(), DBValue::from_slice(&[0x01u8, 0x23])); } diff --git a/util/src/trie/mod.rs b/util/src/trie/mod.rs index cae980505..e4e9cd3ef 100644 --- a/util/src/trie/mod.rs +++ b/util/src/trie/mod.rs @@ -18,6 +18,7 @@ use std::fmt; use hash::H256; +use keccak::KECCAK_NULL_RLP; use hashdb::{HashDB, DBValue}; /// Export the standardmap module. @@ -123,7 +124,7 @@ pub trait Trie { fn root(&self) -> &H256; /// Is the trie empty? - fn is_empty(&self) -> bool { *self.root() == ::sha3::SHA3_NULL_RLP } + fn is_empty(&self) -> bool { *self.root() == KECCAK_NULL_RLP } /// Does the trie contain a given key? fn contains(&self, key: &[u8]) -> Result { diff --git a/util/src/trie/recorder.rs b/util/src/trie/recorder.rs index 8d79b4315..1366ccddd 100644 --- a/util/src/trie/recorder.rs +++ b/util/src/trie/recorder.rs @@ -16,7 +16,7 @@ //! Trie query recorder. -use sha3::Hashable; +use keccak::keccak; use {Bytes, H256}; /// A record of a visited node. @@ -62,7 +62,7 @@ impl Recorder { /// Record a visited node, given its hash, data, and depth. pub fn record(&mut self, hash: &H256, data: &[u8], depth: u32) { - debug_assert_eq!(data.sha3(), *hash); + debug_assert_eq!(keccak(data), *hash); if depth >= self.min_depth { self.nodes.push(Record { @@ -82,7 +82,6 @@ impl Recorder { #[cfg(test)] mod tests { use super::*; - use sha3::Hashable; use ::H256; #[test] @@ -92,7 +91,7 @@ mod tests { let node1 = vec![1, 2, 3, 4]; let node2 = vec![4, 5, 6, 7, 8, 9, 10]; - let (hash1, hash2) = (node1.sha3(), node2.sha3()); + let (hash1, hash2) = (keccak(&node1), keccak(&node2)); basic.record(&hash1, &node1, 0); basic.record(&hash2, &node2, 456); @@ -118,8 +117,8 @@ mod tests { let node1 = vec![1, 2, 3, 4]; let node2 = vec![4, 5, 6, 7, 8, 9, 10]; - let hash1 = node1.sha3(); - let hash2 = node2.sha3(); + let hash1 = keccak(&node1); + let hash2 = keccak(&node2); basic.record(&hash1, &node1, 0); basic.record(&hash2, &node2, 456); diff --git a/util/src/trie/sectriedb.rs b/util/src/trie/sectriedb.rs index b2f344794..59dbe5b3a 100644 --- a/util/src/trie/sectriedb.rs +++ b/util/src/trie/sectriedb.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use hash::H256; -use sha3::Hashable; +use keccak::keccak; use hashdb::HashDB; use super::triedb::TrieDB; use super::{Trie, TrieItem, TrieIterator, Query}; @@ -56,13 +56,13 @@ impl<'db> Trie for SecTrieDB<'db> { fn root(&self) -> &H256 { self.raw.root() } fn contains(&self, key: &[u8]) -> super::Result { - self.raw.contains(&key.sha3()) + self.raw.contains(&keccak(key)) } fn get_with<'a, 'key, Q: Query>(&'a self, key: &'key [u8], query: Q) -> super::Result> where 'a: 'key { - self.raw.get_with(&key.sha3(), query) + self.raw.get_with(&keccak(key), query) } } @@ -77,7 +77,7 @@ fn trie_to_sectrie() { let mut root = H256::default(); { let mut t = TrieDBMut::new(&mut memdb, &mut root); - t.insert(&(&[0x01u8, 0x23]).sha3(), &[0x01u8, 0x23]).unwrap(); + t.insert(&keccak(&[0x01u8, 0x23]), &[0x01u8, 0x23]).unwrap(); } let t = SecTrieDB::new(&memdb, &root).unwrap(); assert_eq!(t.get(&[0x01u8, 0x23]).unwrap().unwrap(), DBValue::from_slice(&[0x01u8, 0x23])); diff --git a/util/src/trie/sectriedbmut.rs b/util/src/trie/sectriedbmut.rs index 5cfdc4b9f..9e53aaff1 100644 --- a/util/src/trie/sectriedbmut.rs +++ b/util/src/trie/sectriedbmut.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use hash::H256; -use sha3::Hashable; +use keccak::keccak; use hashdb::{HashDB, DBValue}; use super::triedbmut::TrieDBMut; use super::TrieMut; @@ -59,21 +59,21 @@ impl<'db> TrieMut for SecTrieDBMut<'db> { } fn contains(&self, key: &[u8]) -> super::Result { - self.raw.contains(&key.sha3()) + self.raw.contains(&keccak(key)) } fn get<'a, 'key>(&'a self, key: &'key [u8]) -> super::Result> where 'a: 'key { - self.raw.get(&key.sha3()) + self.raw.get(&keccak(key)) } fn insert(&mut self, key: &[u8], value: &[u8]) -> super::Result> { - self.raw.insert(&key.sha3(), value) + self.raw.insert(&keccak(key), value) } fn remove(&mut self, key: &[u8]) -> super::Result> { - self.raw.remove(&key.sha3()) + self.raw.remove(&keccak(key)) } } @@ -90,5 +90,5 @@ fn sectrie_to_trie() { t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]).unwrap(); } let t = TrieDB::new(&memdb, &root).unwrap(); - assert_eq!(t.get(&(&[0x01u8, 0x23]).sha3()).unwrap().unwrap(), DBValue::from_slice(&[0x01u8, 0x23])); + assert_eq!(t.get(&keccak(&[0x01u8, 0x23])).unwrap().unwrap(), DBValue::from_slice(&[0x01u8, 0x23])); } diff --git a/util/src/trie/standardmap.rs b/util/src/trie/standardmap.rs index f839f4f2e..0c7c1537e 100644 --- a/util/src/trie/standardmap.rs +++ b/util/src/trie/standardmap.rs @@ -17,8 +17,8 @@ //! Key-value datastore with a modified Merkle tree. extern crate rand; +use keccak::keccak; use bytes::*; -use sha3::*; use hash::*; use rlp::encode; @@ -63,14 +63,14 @@ impl StandardMap { /// `seed` is mutated pseudoramdonly and used. fn random_bytes(min_count: usize, journal_count: usize, seed: &mut H256) -> Vec { assert!(min_count + journal_count <= 32); - *seed = seed.sha3(); + *seed = keccak(&seed); let r = min_count + (seed[31] as usize % (journal_count + 1)); seed[0..r].to_vec() } /// Get a random value. Equal chance of being 1 byte as of 32. `seed` is mutated pseudoramdonly and used. fn random_value(seed: &mut H256) -> Bytes { - *seed = seed.sha3(); + *seed = keccak(&seed); match seed[0] % 2 { 1 => vec![seed[31];1], _ => seed.to_vec(), @@ -81,7 +81,7 @@ impl StandardMap { /// Each byte is an item from `alphabet`. `seed` is mutated pseudoramdonly and used. fn random_word(alphabet: &[u8], min_count: usize, journal_count: usize, seed: &mut H256) -> Vec { assert!(min_count + journal_count <= 32); - *seed = seed.sha3(); + *seed = keccak(&seed); let r = min_count + (seed[31] as usize % (journal_count + 1)); let mut ret: Vec = Vec::with_capacity(r); for i in 0..r { diff --git a/util/src/trie/triedbmut.rs b/util/src/trie/triedbmut.rs index 89eb574dc..fa23ca756 100644 --- a/util/src/trie/triedbmut.rs +++ b/util/src/trie/triedbmut.rs @@ -25,14 +25,13 @@ use ::{HashDB, H256}; use ::bytes::ToPretty; use ::nibbleslice::NibbleSlice; use ::rlp::{Rlp, RlpStream}; -use ::sha3::SHA3_NULL_RLP; use hashdb::DBValue; -use elastic_array::ElasticArray1024; - use std::collections::{HashSet, VecDeque}; use std::mem; use std::ops::Index; +use elastic_array::ElasticArray1024; +use keccak::{KECCAK_NULL_RLP}; // For lookups into the Node storage buffer. // This is deliberately non-copyable. @@ -262,7 +261,9 @@ impl<'a> Index<&'a StorageHandle> for NodeStorage { /// # Example /// ``` /// extern crate ethcore_util as util; +/// extern crate hash; /// +/// use hash::KECCAK_NULL_RLP; /// use util::trie::*; /// use util::hashdb::*; /// use util::memorydb::*; @@ -273,7 +274,7 @@ impl<'a> Index<&'a StorageHandle> for NodeStorage { /// let mut root = H256::new(); /// let mut t = TrieDBMut::new(&mut memdb, &mut root); /// assert!(t.is_empty()); -/// assert_eq!(*t.root(), ::util::sha3::SHA3_NULL_RLP); +/// assert_eq!(*t.root(), KECCAK_NULL_RLP); /// t.insert(b"foo", b"bar").unwrap(); /// assert!(t.contains(b"foo").unwrap()); /// assert_eq!(t.get(b"foo").unwrap().unwrap(), DBValue::from_slice(b"bar")); @@ -295,8 +296,8 @@ pub struct TrieDBMut<'a> { impl<'a> TrieDBMut<'a> { /// Create a new trie with backing database `db` and empty `root`. pub fn new(db: &'a mut HashDB, root: &'a mut H256) -> Self { - *root = SHA3_NULL_RLP; - let root_handle = NodeHandle::Hash(SHA3_NULL_RLP); + *root = KECCAK_NULL_RLP; + let root_handle = NodeHandle::Hash(KECCAK_NULL_RLP); TrieDBMut { storage: NodeStorage::empty(), @@ -871,7 +872,7 @@ impl<'a> TrieMut for TrieDBMut<'a> { fn is_empty(&self) -> bool { match self.root_handle { - NodeHandle::Hash(h) => h == SHA3_NULL_RLP, + NodeHandle::Hash(h) => h == KECCAK_NULL_RLP, NodeHandle::InMemory(ref h) => match self.storage[h] { Node::Empty => true, _ => false, @@ -919,8 +920,8 @@ impl<'a> TrieMut for TrieDBMut<'a> { } None => { trace!(target: "trie", "remove: obliterated trie"); - self.root_handle = NodeHandle::Hash(SHA3_NULL_RLP); - *self.root = SHA3_NULL_RLP; + self.root_handle = NodeHandle::Hash(KECCAK_NULL_RLP); + *self.root = KECCAK_NULL_RLP; } } @@ -941,7 +942,7 @@ mod tests { use memorydb::*; use super::*; use bytes::ToPretty; - use sha3::SHA3_NULL_RLP; + use keccak::KECCAK_NULL_RLP; use super::super::TrieMut; use super::super::standardmap::*; @@ -996,7 +997,7 @@ mod tests { assert_eq!(*memtrie.root(), real); unpopulate_trie(&mut memtrie, &x); memtrie.commit(); - if *memtrie.root() != SHA3_NULL_RLP { + if *memtrie.root() != KECCAK_NULL_RLP { println!("- TRIE MISMATCH"); println!(""); println!("{:?} vs {:?}", memtrie.root(), real); @@ -1004,7 +1005,7 @@ mod tests { println!("{:?} -> {:?}", i.0.pretty(), i.1.pretty()); } } - assert_eq!(*memtrie.root(), SHA3_NULL_RLP); + assert_eq!(*memtrie.root(), KECCAK_NULL_RLP); } } @@ -1013,7 +1014,7 @@ mod tests { let mut memdb = MemoryDB::new(); let mut root = H256::new(); let mut t = TrieDBMut::new(&mut memdb, &mut root); - assert_eq!(*t.root(), SHA3_NULL_RLP); + assert_eq!(*t.root(), KECCAK_NULL_RLP); } #[test] @@ -1268,7 +1269,7 @@ mod tests { } assert!(t.is_empty()); - assert_eq!(*t.root(), SHA3_NULL_RLP); + assert_eq!(*t.root(), KECCAK_NULL_RLP); } #[test] diff --git a/util/src/triehash.rs b/util/src/triehash.rs index 62d3dbf97..fa790f3f4 100644 --- a/util/src/triehash.rs +++ b/util/src/triehash.rs @@ -21,7 +21,7 @@ use std::collections::BTreeMap; use std::cmp; use hash::*; -use sha3::*; +use keccak::keccak; use rlp; use rlp::RlpStream; use vector::SharedPrefix; @@ -115,7 +115,7 @@ pub fn sec_trie_root(input: Vec<(Vec, Vec)>) -> H256 { let gen_input = input // first put elements into btree to sort them and to remove duplicates .into_iter() - .map(|(k, v)| (k.sha3(), v)) + .map(|(k, v)| (keccak(k), v)) .collect::>() // then move them to a vector .into_iter() @@ -128,7 +128,7 @@ pub fn sec_trie_root(input: Vec<(Vec, Vec)>) -> H256 { fn gen_trie_root(input: Vec<(Vec, Vec)>) -> H256 { let mut stream = RlpStream::new(); hash256rlp(&input, 0, &mut stream); - stream.out().sha3() + keccak(stream.out()) } /// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1. @@ -271,7 +271,7 @@ fn hash256aux(input: &[(Vec, Vec)], pre_len: usize, stream: &mut RlpStre let out = s.out(); match out.len() { 0...31 => stream.append_raw(&out, 1), - _ => stream.append(&out.sha3()) + _ => stream.append(&keccak(out)) }; }