complex proof (binary tree hash).

Cargo.toml

@@ -3,6 +3,7 @@ members = [
 	"hash-db",
 	"memory-db",
 	"hash256-std-hasher",
+	"ordered-trie",
 	"test-support/keccak-hasher",
 	"test-support/reference-trie",
 	"test-support/trie-standardmap",

hash-db/src/lib.rs

@@ -64,6 +64,48 @@ pub trait Hasher: Sync + Send {
 	fn hash(x: &[u8]) -> Self::Out;
 }
 
+/// Small trait for to allow using buffer of type [u8; H::LENGTH * 2].
+pub trait BinaryHasher: Hasher {
+	/// Hash for the empty content (is hash(&[])).
+	const NULL_HASH: &'static [u8];
+
+	/// State buffer for hashing.
+	type Buffer;
+
+	fn init_buffer() -> Self::Buffer;
+	fn reset_buffer(buf: &mut Self::Buffer);
+	fn buffer_hash(buff: &mut Self::Buffer, x: &[u8]);
+
+	/// After calling `buffer_finalize`, one do not have to call `reset_buffer`.
+	fn buffer_finalize(buff: &mut Self::Buffer) -> Self::Out;
+}
+
+#[cfg(feature = "std")]
+/// Test function to use on any binary buffer implementation.
+pub fn test_binary_hasher<H: BinaryHasher>() {
+	let size = <H as Hasher>::LENGTH * 2;
+	let half_size = <H as Hasher>::LENGTH / 2;
+	let mut val = vec![0u8; size];
+	val[0] = 1;
+	let mut buf = <H as BinaryHasher>::init_buffer();
+	H::buffer_hash(&mut buf, &val[..half_size]);
+	H::buffer_hash(&mut buf, &val[half_size..<H as Hasher>::LENGTH]);
+	let three = core::cmp::min(3, half_size);
+	H::buffer_hash(&mut buf, &val[<H as Hasher>::LENGTH..<H as Hasher>::LENGTH + three]);
+	H::buffer_hash(&mut buf, &val[<H as Hasher>::LENGTH + three..]);
+	let h = H::buffer_finalize(&mut buf);
+	let h2 = H::hash(&val[..]);
+	assert_eq!(h, h2);
+	H::buffer_hash(&mut buf, &val[..]);
+	let h = H::buffer_finalize(&mut buf);
+	assert_eq!(h, h2);
+	let null_hash = H::hash(&[]);
+	H::reset_buffer(&mut buf);
+	let null_hash2 = H::buffer_finalize(&mut buf);
+	assert_eq!(H::NULL_HASH, null_hash.as_ref());
+	assert_eq!(H::NULL_HASH, null_hash2.as_ref());
+}
+
 /// Trait modelling a plain datastore whose key is a fixed type.
 /// The caller should ensure that a key only corresponds to
 /// one value.
@@ -185,3 +227,80 @@ impl<'a, K, V> AsPlainDB<K, V> for &'a mut dyn PlainDB<K, V> {
 	fn as_plain_db(&self) -> &dyn PlainDB<K, V> { &**self }
 	fn as_plain_db_mut<'b>(&'b mut self) -> &'b mut (dyn PlainDB<K, V> + 'b) { &mut **self }
 }
+
+/// Same as HashDB but can modify the value upon storage, and apply
+/// `HasherHybrid`.
+pub trait HashDBHybrid<H: HasherHybrid, T>: Send + Sync + HashDB<H, T> {
+	/// `HashDB` is often use to load content from encoded node.
+	/// This will not preserve insertion done through `insert_branch_hybrid` calls
+	/// and break the proof.
+	/// This function allows to use a callback (usually the call back
+	/// will check the encoded value with codec and for branch it will
+	/// emplace over the hash_hybrid key) for changing key of some content.
+	/// Callback is allow to fail (since it will decode some node this indicates
+	/// invalid content earlier), in this case we return false.
+	fn insert_hybrid(
+		&mut self,
+		prefix: Prefix,
+		value: &[u8],
+		callback: fn(&[u8]) -> core::result::Result<Option<H::Out>, ()>,
+	) -> bool;
+
+	/// Insert a datum item into the DB and return the datum's hash for a later lookup. Insertions
+	/// are counted and the equivalent number of `remove()`s must be performed before the data
+	/// is considered dead.
+	fn insert_branch_hybrid<
+		I: Iterator<Item = Option<H::Out>>,
+	>(
+		&mut self,
+		prefix: Prefix,
+		value: &[u8],
+		no_child_value: &[u8],
+		nb_children: usize,
+		children: I,
+		buffer: &mut <H::InnerHasher as BinaryHasher>::Buffer,
+	) -> H::Out;
+
+	/// Insert with data from a proof.
+	/// As a result, this function can fail.
+	fn insert_branch_hybrid_proof<
+		I: Iterator<Item = Option<H::Out>>,
+		I2: Iterator<Item = H::Out>,
+	>(
+		&mut self,
+		prefix: Prefix,
+		value: &[u8],
+		no_child_value: &[u8],
+		nb_children: usize,
+		children: I,
+		additional_hashes: I2,
+		buffer: &mut <H::InnerHasher as BinaryHasher>::Buffer,
+	) -> Option<H::Out>;
+}
+
+pub trait HasherHybrid: BinaryHasher {
+	type InnerHasher: BinaryHasher<Out = Self::Out>;
+
+	/// Alternate hash with hybrid hashing allowed.
+	fn hash_hybrid<
+		I: Iterator<Item = Option<<Self as Hasher>::Out>>,
+	>(
+		encoded_node: &[u8],
+		nb_children: usize,
+		children: I,
+		buffer: &mut <Self::InnerHasher as BinaryHasher>::Buffer,
+	) -> Self::Out;
+
+	/// Calculate hash from a proof, this can fail.
+	fn hash_hybrid_proof<
+		I: Iterator<Item = Option<<Self as Hasher>::Out>>,
+		I2: Iterator<Item = <Self::InnerHasher as Hasher>::Out>,
+	>(
+		x: &[u8],
+		nb_children: usize,
+		children: I,
+		additional_hashes: I2,
+		buffer: &mut <Self::InnerHasher as BinaryHasher>::Buffer,
+	) -> Option<Self::Out>;
+
+}

memory-db/src/lib.rs

@@ -23,7 +23,7 @@ mod malloc_size_of;
 pub use malloc_size_of::*;
 
 use hash_db::{HashDB, HashDBRef, PlainDB, PlainDBRef, Hasher as KeyHasher,
-	AsHashDB, AsPlainDB, Prefix};
+	AsHashDB, AsPlainDB, Prefix, HashDBHybrid, HasherHybrid, BinaryHasher};
 use parity_util_mem::{MallocSizeOf, MallocSizeOfOps, MallocShallowSizeOf};
 #[cfg(feature = "std")]
 use std::{
@@ -34,6 +34,7 @@ use std::{
 	marker::PhantomData,
 	cmp::Eq,
 	borrow::Borrow,
+	result,
 };
 
 #[cfg(not(feature = "std"))]
@@ -49,6 +50,8 @@ use core::{
 	marker::PhantomData,
 	cmp::Eq,
 	borrow::Borrow,
+	ops::Range,
+	result,
 };
 
 #[cfg(not(feature = "std"))]
@@ -625,6 +628,86 @@ where
 	}
 }
 
+impl<H, KF, T, M> HashDBHybrid<H, T> for MemoryDB<H, KF, T, M>
+where
+	H: HasherHybrid,
+	T: Default + PartialEq<T> + for<'a> From<&'a [u8]> + Clone + Send + Sync,
+	KF: Send + Sync + KeyFunction<H>,
+	M: MemTracker<T> + Send + Sync,
+{
+	fn insert_hybrid(
+		&mut self,
+		prefix: Prefix,
+		value: &[u8],
+		callback: fn(&[u8]) -> result::Result<Option<H::Out>, ()>,
+	) -> bool {
+		if let Ok(result) = callback(value) {
+			if let Some(key) = result {
+				<Self as HashDB<H, T>>::emplace(self, key, prefix, T::from(value));
+			} else {
+				<Self as HashDB<H, T>>::insert(self, prefix, value);
+			}
+			true
+		} else {
+			false
+		}
+	}
+
+	fn insert_branch_hybrid<
+		I: Iterator<Item = Option<H::Out>>,
+	> (
+		&mut self,
+		prefix: Prefix,
+		value: &[u8],
+		child_proof_header: &[u8],
+		nb_children: usize,
+		children: I,
+		buff: &mut <H::InnerHasher as BinaryHasher>::Buffer,
+	) -> H::Out {
+		if T::from(value) == self.null_node_data {
+			return self.hashed_null_node.clone();
+		}
+
+		let key = H::hash_hybrid(
+			child_proof_header,
+			nb_children,
+			children,
+			buff,
+		);
+		HashDB::emplace(self, key, prefix, value.into());
+		key
+	}
+
+	fn insert_branch_hybrid_proof<
+		I: Iterator<Item = Option<H::Out>>,
+		I2: Iterator<Item = H::Out>,
+	> (
+		&mut self,
+		prefix: Prefix,
+		value: &[u8],
+		child_proof_header: &[u8],
+		nb_children: usize,
+		children: I,
+		additional_hashes: I2,
+		buff: &mut <H::InnerHasher as BinaryHasher>::Buffer,
+	) -> Option<H::Out> {
+		if T::from(value) == self.null_node_data {
+			return Some(self.hashed_null_node.clone());
+		}
+
+		H::hash_hybrid_proof(
+			child_proof_header,
+			nb_children,
+			children,
+			additional_hashes,
+			buff,
+		).map(|key| {
+			HashDB::emplace(self, key, prefix, value.into());
+			key
+		})
+	}
+}
+
 impl<H, KF, T, M> HashDBRef<H, T> for MemoryDB<H, KF, T, M>
 where
 	H: KeyHasher,

ordered-trie/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "ordered-trie"
+version = "0.19.2"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Binary tree generic for ordered values (stack or fifo)"
+repository = "https://github.com/paritytech/trie"
+license = "Apache-2.0"
+edition = "2018"
+
+[dependencies]
+hash-db = { path = "../hash-db", default-features = false, version = "0.15.2"}
+smallvec = "1.0.0"
+
+[dev-dependencies]
+keccak-hasher = { path = "../test-support/keccak-hasher", version = "0.15.2"}
+#criterion = "0.2.8"
+
+
+[features]
+default = ["std"]
+std = [
+  "hash-db/std",
+]