Use parity-common to make substrate generic over hasher and trie encoding codec

.gitignore

@@ -1,4 +1,4 @@
-/target/
+**/target/
 **/*.rs.bk
 *.swp
 .wasm-binaries

substrate/client/db/Cargo.toml

@@ -6,12 +6,12 @@ authors = ["Parity Technologies <[email protected]>"]
 [dependencies]
 parking_lot = "0.4"
 log = "0.3"
-kvdb = { git = "https://github.com/paritytech/parity.git" }
-kvdb-rocksdb = { git = "https://github.com/paritytech/parity.git" }
+kvdb = { git = "https://github.com/paritytech/parity-common" }
+kvdb-rocksdb = { git = "https://github.com/paritytech/parity-common" }
 ethereum-types = "0.3"
-hashdb = { git = "https://github.com/paritytech/parity.git" }
-patricia-trie = { git = "https://github.com/paritytech/parity.git" }
-memorydb = { git = "https://github.com/paritytech/parity.git" }
+hashdb = { git = "https://github.com/paritytech/parity-common" }
+patricia-trie = { git = "https://github.com/paritytech/parity-common" }
+memorydb = { git = "https://github.com/paritytech/parity-common" }
 substrate-primitives = { path = "../../../substrate/primitives" }
 substrate-runtime-primitives = { path = "../../../substrate/runtime/primitives" }
 substrate-client = { path = "../../../substrate/client" }
@@ -22,4 +22,4 @@ substrate-executor = { path = "../../../substrate/executor" }
 substrate-state-db = { path = "../../../substrate/state-db" }
 
 [dev-dependencies]
-kvdb-memorydb = { git = "https://github.com/paritytech/parity.git" }
+kvdb-memorydb = { git = "https://github.com/paritytech/parity-common" }

substrate/keystore/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 authors = ["Parity Technologies <[email protected]>"]
 
 [dependencies]
-ethcore-crypto = { git = "https://github.com/paritytech/parity.git", default_features = false }
+parity-crypto = { git = "https://github.com/paritytech/parity-common.git", default_features = false }
 ed25519 = { path = "../ed25519" }
 error-chain = "0.12"
 hex = "0.3"

substrate/state-machine/Cargo.toml

@@ -10,10 +10,17 @@ ethereum-types = "0.3"
 hex-literal = "0.1.0"
 log = "0.3"
 parking_lot = "0.4"
-triehash = "0.1"
 
 substrate-primitives = { path = "../primitives", version = "0.1.0" }
 
-hashdb = { git = "https://github.com/paritytech/parity.git" }
-memorydb = { git = "https://github.com/paritytech/parity.git" }
-patricia-trie = { git = "https://github.com/paritytech/parity.git" }
+hashdb = { git = "https://github.com/paritytech/parity-common" }
+memorydb = { git = "https://github.com/paritytech/parity-common" }
+patricia-trie = { git = "https://github.com/paritytech/parity-common" }
+triehash = { git = "https://github.com/paritytech/parity-common" }
+rlp = { git = "https://github.com/paritytech/parity-common" }
+
+[dev-dependencies]
+# We need `KeccakHasher` from here
+keccak-hasher = { git = "https://github.com/paritytech/parity" }
+# We need `RlpCodec` from here
+patricia-trie-ethereum = { git = "https://github.com/paritytech/parity" }

substrate/state-machine/src/backend.rs

@@ -17,15 +17,21 @@
 //! State machine backends. These manage the code and storage of contracts.
 
 use std::{error, fmt};
+use std::cmp::Ord;
 use std::collections::HashMap;
+use std::marker::PhantomData;
 use std::sync::Arc;
+
+use hashdb::Hasher;
+use rlp::Encodable;
 use trie_backend::{TryIntoTrieBackend, TrieBackend};
+use patricia_trie::{TrieDBMut, TrieMut, NodeCodec};
 
 /// A state backend is used to read state data and can have changes committed
 /// to it.
 ///
 /// The clone operation (if implemented) should be cheap.
-pub trait Backend: TryIntoTrieBackend {
+pub trait Backend<H: Hasher, C: NodeCodec<H>>: TryIntoTrieBackend<H, C> {
 	/// An error type when fetching data is not possible.
 	type Error: super::Error;
 
@@ -41,8 +47,10 @@ pub trait Backend: TryIntoTrieBackend {
 
 	/// Calculate the storage root, with given delta over what is already stored in
 	/// the backend, and produce a "transaction" that can be used to commit.
-	fn storage_root<I>(&self, delta: I) -> ([u8; 32], Self::Transaction)
-		where I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>;
+	fn storage_root<I>(&self, delta: I) -> (H::Out, Self::Transaction)
+	where
+		I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>,
+		H::Out: Ord + Encodable;
 
 	/// Get all key/value pairs into a Vec.
 	fn pairs(&self) -> Vec<(Vec<u8>, Vec<u8>)>;
@@ -66,21 +74,25 @@ impl error::Error for Void {
 /// In-memory backend. Fully recomputes tries on each commit but useful for
 /// tests.
 #[derive(Clone, PartialEq, Eq)]
-pub struct InMemory {
+pub struct InMemory<H, C> {
 	inner: Arc<HashMap<Vec<u8>, Vec<u8>>>,
+	_hasher: PhantomData<H>,
+	_codec: PhantomData<C>,
 }
 
-impl Default for InMemory {
+impl<H, C> Default for InMemory<H, C> {
 	fn default() -> Self {
 		InMemory {
 			inner: Arc::new(Default::default()),
+			_hasher: PhantomData,
+			_codec: PhantomData,
 		}
 	}
 }
 
-impl InMemory {
+impl<H: Hasher, C: NodeCodec<H>> InMemory<H, C> {
 	/// Copy the state, with applied updates
-	pub fn update(&self, changes: <Self as Backend>::Transaction) -> Self {
+	pub fn update(&self, changes: <Self as Backend<H, C>>::Transaction) -> Self {
 		let mut inner: HashMap<_, _> = (&*self.inner).clone();
 		for (key, val) in changes {
 			match val {
@@ -93,15 +105,15 @@ impl InMemory {
 	}
 }
 
-impl From<HashMap<Vec<u8>, Vec<u8>>> for InMemory {
+impl<H, C> From<HashMap<Vec<u8>, Vec<u8>>> for InMemory<H, C> {
 	fn from(inner: HashMap<Vec<u8>, Vec<u8>>) -> Self {
 		InMemory {
-			inner: Arc::new(inner),
+			inner: Arc::new(inner), _hasher: PhantomData, _codec: PhantomData
 		}
 	}
 }
 
-impl Backend for InMemory {
+impl<H: Hasher, C: NodeCodec<H>> Backend<H, C> for InMemory<H, C> {
 	type Error = Void;
 	type Transaction = Vec<(Vec<u8>, Option<Vec<u8>>)>;
 
@@ -113,17 +125,19 @@ impl Backend for InMemory {
 		self.inner.keys().filter(|key| key.starts_with(prefix)).map(|k| &**k).for_each(f);
 	}
 
-	fn storage_root<I>(&self, delta: I) -> ([u8; 32], Self::Transaction)
-		where I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>
+	fn storage_root<I>(&self, delta: I) -> (H::Out, Self::Transaction)
+	where
+		I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>,
+		<H as Hasher>::Out: Ord + Encodable,
 	{
 		let existing_pairs = self.inner.iter().map(|(k, v)| (k.clone(), Some(v.clone())));
 
 		let transaction: Vec<_> = delta.into_iter().collect();
-		let root = ::triehash::trie_root(existing_pairs.chain(transaction.iter().cloned())
+		let root = ::triehash::trie_root::<H, _, _, _>(existing_pairs.chain(transaction.iter().cloned())
 			.collect::<HashMap<_, _>>()
 			.into_iter()
 			.filter_map(|(k, maybe_val)| maybe_val.map(|val| (k, val)))
-		).0;
+		);
 
 		(root, transaction)
 	}
@@ -133,16 +147,13 @@ impl Backend for InMemory {
 	}
 }
 
-impl TryIntoTrieBackend for InMemory {
-	fn try_into_trie_backend(self) -> Option<TrieBackend> {
-		use ethereum_types::H256 as TrieH256;
+impl<H: Hasher, C: NodeCodec<H>> TryIntoTrieBackend<H, C> for InMemory<H, C> {
+	fn try_into_trie_backend(self) -> Option<TrieBackend<H, C>> {
 		use memorydb::MemoryDB;
-		use patricia_trie::{TrieDBMut, TrieMut};
-
-		let mut root = TrieH256::default();
-		let mut mdb = MemoryDB::default();
+		let mut root = <H as Hasher>::Out::default();
+		let mut mdb = MemoryDB::new();
 		{
-			let mut trie = TrieDBMut::new(&mut mdb, &mut root);
+			let mut trie = TrieDBMut::<H, C>::new(&mut mdb, &mut root);
 			for (key, value) in self.inner.iter() {
 				if let Err(e) = trie.insert(&key, &value) {
 					warn!(target: "trie", "Failed to write to trie: {}", e);

substrate/state-machine/src/ext.rs

@@ -16,9 +16,12 @@
 
 //! Conrete externalities implementation.
 
-use std::{error, fmt};
+use std::{error, fmt, cmp::Ord};
 use backend::Backend;
 use {Externalities, OverlayedChanges};
+use hashdb::Hasher;
+use rlp::Encodable;
+use patricia_trie::NodeCodec;
 
 /// Errors that can occur when interacting with the externalities.
 #[derive(Debug, Copy, Clone)]
@@ -50,16 +53,22 @@ impl<B: error::Error, E: error::Error> error::Error for Error<B, E> {
 }
 
 /// Wraps a read-only backend, call executor, and current overlayed changes.
-pub struct Ext<'a, B: 'a + Backend> {
+pub struct Ext<'a, H: Hasher, C: NodeCodec<H>, B: 'a + Backend<H, C>> { //TODO: can I get rid of the trait bounds here?
 	// The overlayed changes to write to.
 	overlay: &'a mut OverlayedChanges,
 	// The storage backend to read from.
 	backend: &'a B,
 	// The transaction necessary to commit to the backend.
-	transaction: Option<(B::Transaction, [u8; 32])>,
+	transaction: Option<(B::Transaction, H::Out)>,
 }
 
-impl<'a, B: 'a + Backend> Ext<'a, B> {
+impl<'a, H, C, B> Ext<'a, H, C, B>
+where
+	H: Hasher,
+	C: NodeCodec<H>,
+	B: 'a + Backend<H, C>,
+	H::Out: Ord + Encodable
+{
 	/// Create a new `Ext` from overlayed changes and read-only backend
 	pub fn new(overlay: &'a mut OverlayedChanges, backend: &'a B) -> Self {
 		Ext {
@@ -84,7 +93,7 @@ impl<'a, B: 'a + Backend> Ext<'a, B> {
 }
 
 #[cfg(test)]
-impl<'a, B: 'a + Backend> Ext<'a, B> {
+impl<'a, H: Hasher, C: NodeCodec<H>, B: 'a + Backend<H, C>> Ext<'a, H, C, B> {
 	pub fn storage_pairs(&self) -> Vec<(Vec<u8>, Vec<u8>)> {
 		use std::collections::HashMap;
 
@@ -99,8 +108,12 @@ impl<'a, B: 'a + Backend> Ext<'a, B> {
 	}
 }
 
-impl<'a, B: 'a> Externalities for Ext<'a, B>
-	where B: Backend
+impl<'a, B: 'a, H, C> Externalities<H> for Ext<'a, H, C, B>
+where
+	H: Hasher,
+	C: NodeCodec<H>,
+	B: 'a + Backend<H, C>,
+	H::Out: Ord + Encodable
 {
 	fn storage(&self, key: &[u8]) -> Option<Vec<u8>> {
 		self.overlay.storage(key).map(|x| x.map(|x| x.to_vec())).unwrap_or_else(||
@@ -123,7 +136,7 @@ impl<'a, B: 'a> Externalities for Ext<'a, B>
 		42
 	}
 
-	fn storage_root(&mut self) -> [u8; 32] {
+	fn storage_root(&mut self) -> H::Out where H::Out: Ord + Encodable {
 		if let Some((_, ref root)) =  self.transaction {
 			return root.clone();
 		}