WIP start adding NodeCodec

substrate/state-machine/src/backend.rs

@@ -25,12 +25,13 @@ 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<H: Hasher>: TryIntoTrieBackend<H> {
+pub trait Backend<H: Hasher, C: NodeCodec<H>>: TryIntoTrieBackend<H, C> {
 	/// An error type when fetching data is not possible.
 	type Error: super::Error;
 
@@ -73,23 +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<H> {
+pub struct InMemory<H, C> {
 	inner: Arc<HashMap<Vec<u8>, Vec<u8>>>,
-	_marker: PhantomData<H>,
+	_hasher: PhantomData<H>,
+	_codec: PhantomData<C>,
 }
 
-impl<H> Default for InMemory<H> {
+impl<H, C> Default for InMemory<H, C> {
 	fn default() -> Self {
 		InMemory {
 			inner: Arc::new(Default::default()),
-			_marker: PhantomData,
+			_hasher: PhantomData,
+			_codec: PhantomData,
 		}
 	}
 }
 
-impl<H: Hasher> InMemory<H> {
+impl<H: Hasher, C: NodeCodec<H>> InMemory<H, C> {
 	/// Copy the state, with applied updates
-	pub fn update(&self, changes: <Self as Backend<H>>::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 {
@@ -102,15 +105,15 @@ impl<H: Hasher> InMemory<H> {
 	}
 }
 
-impl<H> From<HashMap<Vec<u8>, Vec<u8>>> for InMemory<H> {
+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), _marker: PhantomData
+			inner: Arc::new(inner), _hasher: PhantomData, _codec: PhantomData
 		}
 	}
 }
 
-impl<H: Hasher> Backend<H> for InMemory<H> {
+impl<H: Hasher, C: NodeCodec<H>> Backend<H, C> for InMemory<H, C> {
 	type Error = Void;
 	type Transaction = Vec<(Vec<u8>, Option<Vec<u8>>)>;
 
@@ -144,15 +147,13 @@ impl<H: Hasher> Backend<H> for InMemory<H> {
 	}
 }
 
-impl<H: Hasher> TryIntoTrieBackend<H> for InMemory<H> {
+impl<H: Hasher, C: NodeCodec<H>> TryIntoTrieBackend<H, C> for InMemory<H, C> {
 	fn try_into_trie_backend(self) -> Option<TrieBackend<H>> {
 		use memorydb::MemoryDB;
-		use patricia_trie::{TrieDBMut, TrieMut};
-
 		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

@@ -21,6 +21,7 @@ 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)]
@@ -52,7 +53,7 @@ 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, H: Hasher, B: 'a + Backend<H>> {
+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.
@@ -61,10 +62,11 @@ pub struct Ext<'a, H: Hasher, B: 'a + Backend<H>> {
 	transaction: Option<(B::Transaction, H::Out)>,
 }
 
-impl<'a, H, B> Ext<'a, H, B>
+impl<'a, H, C, B> Ext<'a, H, C, B>
 where
 	H: Hasher,
-	B: 'a + Backend<H>,
+	C: NodeCodec<H>,
+	B: 'a + Backend<H, C>,
 	H::Out: Ord + Encodable
 {
 	/// Create a new `Ext` from overlayed changes and read-only backend
@@ -106,10 +108,11 @@ impl<'a, B: 'a + Backend> Ext<'a, B> {
 	}
 }
 
-impl<'a, B: 'a, H> Externalities<H> for Ext<'a, H, B>
+impl<'a, B: 'a, H, C> Externalities<H> for Ext<'a, H, C, B>
 where
 	H: Hasher,
-	B: 'a + Backend<H>,
+	C: NodeCodec<H>,
+	B: 'a + Backend<H, C>,
 	H::Out: Ord + Encodable
 {
 	fn storage(&self, key: &[u8]) -> Option<Vec<u8>> {

substrate/state-machine/src/lib.rs

@@ -36,8 +36,9 @@ extern crate rlp;
 use std::collections::HashMap;
 use std::collections::hash_map::Drain;
 use std::fmt;
-use rlp::Encodable;
 use hashdb::Hasher;
+use patricia_trie::NodeCodec;
+use rlp::Encodable;
 
 pub mod backend;
 mod ext;
@@ -170,7 +171,7 @@ pub trait CodeExecutor<H: Hasher>: Sized + Send + Sync {
 ///
 /// Note: changes to code will be in place if this call is made again. For running partial
 /// blocks (e.g. a transaction at a time), ensure a different method is used.
-pub fn execute<B, Exec, H>(
+pub fn execute<H, C, B, Exec>(
 	backend: &B,
 	overlay: &mut OverlayedChanges,
 	exec: &Exec,
@@ -179,8 +180,9 @@ pub fn execute<B, Exec, H>(
 ) -> Result<(Vec<u8>, B::Transaction), Box<Error>>
 where
 	H: Hasher,
+	C: NodeCodec<H>,
 	Exec: CodeExecutor<H>,
-	B: Backend<H>,
+	B: Backend<H, C>,
 	H::Out: Ord + Encodable
 {
 	let result = {
@@ -219,29 +221,30 @@ where
 ///
 /// Note: changes to code will be in place if this call is made again. For running partial
 /// blocks (e.g. a transaction at a time), ensure a different method is used.
-pub fn prove_execution<B, Exec, H>(
+pub fn prove_execution<H, C, B, Exec>(
 	backend: B,
 	overlay: &mut OverlayedChanges,
 	exec: &Exec,
 	method: &str,
 	call_data: &[u8],
-) -> Result<(Vec<u8>, Vec<Vec<u8>>, <TrieBackend<H> as Backend<H>>::Transaction), Box<Error>>
+) -> Result<(Vec<u8>, Vec<Vec<u8>>, <TrieBackend<H> as Backend<H, C>>::Transaction), Box<Error>>
 where
 	H: Hasher,
 	Exec: CodeExecutor<H>,
-	B: TryIntoTrieBackend<H>,
+	C: NodeCodec<H>,
+	B: TryIntoTrieBackend<H, C>,
 	H::Out: Ord + Encodable
 {
 	let trie_backend = backend.try_into_trie_backend()
 		.ok_or_else(|| Box::new(ExecutionError::UnableToGenerateProof) as Box<Error>)?;
 	let proving_backend = proving_backend::ProvingBackend::new(trie_backend);
-	let (result, transaction) = execute(&proving_backend, overlay, exec, method, call_data)?;
+	let (result, transaction) = execute::<H, C, _, _>(&proving_backend, overlay, exec, method, call_data)?;
 	let proof = proving_backend.extract_proof();
 	Ok((result, proof, transaction))
 }
 
 /// Check execution proof, generated by `prove_execution` call.
-pub fn execution_proof_check<Exec, H>(
+pub fn execution_proof_check<H, C, Exec>(
 	root: H::Out,
 	proof: Vec<Vec<u8>>,
 	overlay: &mut OverlayedChanges,
@@ -251,11 +254,12 @@ pub fn execution_proof_check<Exec, H>(
 ) -> Result<(Vec<u8>, memorydb::MemoryDB<H>), Box<Error>>
 where
 	H: Hasher,
+	C: NodeCodec<H>,
 	Exec: CodeExecutor<H>,
 	H::Out: Ord + Encodable
 {
-	let backend = proving_backend::create_proof_check_backend(root, proof)?;
-	execute(&backend, overlay, exec, method, call_data)
+	let backend = proving_backend::create_proof_check_backend::<H, C>(root, proof)?;
+	execute::<H, C, _, _>(&backend, overlay, exec, method, call_data)
 }
 
 #[cfg(test)]

substrate/state-machine/src/proving_backend.rs

@@ -17,26 +17,28 @@
 //! Proving state machine backend.
 
 use std::cell::RefCell;
+use std::marker::PhantomData;
 use hashdb::{Hasher, HashDB};
 use memorydb::MemoryDB;
-use patricia_trie::{TrieDB, TrieError, Trie, Recorder};
+use patricia_trie::{TrieDB, Trie, Recorder, NodeCodec};
 use trie_backend::{TrieBackend, Ephemeral};
 use {Error, ExecutionError, Backend, TryIntoTrieBackend};
 use rlp::Encodable;
 
 /// Patricia trie-based backend which also tracks all touched storage trie values.
 /// These can be sent to remote node and used as a proof of execution.
-pub struct ProvingBackend<H: Hasher> {
+pub struct ProvingBackend<H: Hasher, C: NodeCodec<H>> {
 	backend: TrieBackend<H>,
 	proof_recorder: RefCell<Recorder<H::Out>>,
+	marker: PhantomData<C> // TODO: try to remove this if possible
 }
 
-impl<H: Hasher> ProvingBackend<H> {
+impl<H: Hasher, C: NodeCodec<H>> ProvingBackend<H, C> {
 	/// Create new proving backend.
 	pub fn new(backend: TrieBackend<H>) -> Self {
 		ProvingBackend {
 			backend,
-			proof_recorder: RefCell::new(Recorder::new()),
+			proof_recorder: RefCell::new(Recorder::new()), marker: PhantomData
 		}
 	}
 
@@ -50,9 +52,10 @@ impl<H: Hasher> ProvingBackend<H> {
 	}
 }
 
-impl<H> Backend<H> for ProvingBackend<H>
+impl<H, C> Backend<H, C> for ProvingBackend<H, C>
 where
 	H: Hasher,
+	C: NodeCodec<H>,
 	H::Out: Ord + Encodable
 {
 	type Error = String;
@@ -64,14 +67,16 @@ where
 			self.backend.backend_storage(),
 			&mut read_overlay,
 		);
-		let map_e = |e: Box<TrieError<H::Out, Self::Error>>| format!("Trie lookup error: {}", e);
+		// let map_e = |e: Box<TrieError<H::Out, Self::Error>>| format!("Trie lookup error: {}", e);
+		let map_e = |e| format!("Trie lookup error: {}", e);
 
 		let mut proof_recorder = self.proof_recorder.try_borrow_mut()
 			.expect("only fails when already borrowed; storage() is non-reentrant; qed");
-		TrieDB::new(&eph, &self.backend.root()).map_err(map_e)?
+		TrieDB::<H, C>::new(&eph, &self.backend.root()).map_err(map_e)?
 			.get_with(key, &mut *proof_recorder).map(|x| x.map(|val| val.to_vec())).map_err(map_e)
 	}
 
+	// TODO: "error[E0283]: type annotations required: cannot resolve `_: patricia_trie::NodeCodec<H>`"/"note: required because of the requirements on the impl of `backend::Backend<H, _>` for `trie_backend::TrieBackend<H>`")
 	fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F) {
 		self.backend.for_keys_with_prefix(prefix, f)
 	}
@@ -87,14 +92,21 @@ where
 	}
 }
 
-impl<H: Hasher> TryIntoTrieBackend<H> for ProvingBackend<H> {
+impl<H: Hasher, C: NodeCodec<H>> TryIntoTrieBackend<H, C> for ProvingBackend<H, C> {
 	fn try_into_trie_backend(self) -> Option<TrieBackend<H>> {
 		None
 	}
 }
 
 /// Create proof check backend.
-pub fn create_proof_check_backend<H: Hasher>(root: H::Out, proof: Vec<Vec<u8>>) -> Result<TrieBackend<H>, Box<Error>> {
+pub fn create_proof_check_backend<H, C>(
+	root: H::Out,
+	proof: Vec<Vec<u8>>
+) -> Result<TrieBackend<H>, Box<Error>>
+where
+	H: Hasher,
+	C: NodeCodec<H>,
+{
 	let mut db = MemoryDB::new();
 	for item in proof {
 		db.insert(&item);

substrate/state-machine/src/trie_backend.rs

@@ -19,7 +19,7 @@
 use Backend;
 use hashdb::{Hasher, HashDB, AsHashDB};
 use memorydb::MemoryDB;
-use patricia_trie::{TrieDB, TrieDBMut, TrieError, Trie, TrieMut};
+use patricia_trie::{TrieDB, TrieDBMut, TrieError, Trie, TrieMut, NodeCodec};
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -32,7 +32,7 @@ pub trait Storage<H: Hasher>: Send + Sync {
 }
 
 /// Try convert into trie-based backend.
-pub trait TryIntoTrieBackend<H: Hasher> {
+pub trait TryIntoTrieBackend<H: Hasher, C: NodeCodec<H>> {
 	/// Try to convert self into trie backend.
 	fn try_into_trie_backend(self) -> Option<TrieBackend<H>>;
 }
@@ -82,7 +82,7 @@ impl<H: Hasher> TrieBackend<H> {
 	}
 }
 
-impl<H: Hasher> Backend<H> for TrieBackend<H> {
+impl<H: Hasher, C: NodeCodec<H>> Backend<H, C> for TrieBackend<H> {
 	type Error = String;
 	type Transaction = MemoryDB<H>;
 
@@ -93,6 +93,7 @@ impl<H: Hasher> Backend<H> for TrieBackend<H> {
 			overlay: &mut read_overlay,
 		};
 
+		// TODO: this is probably wrong too
 		let map_e = |e: Box<TrieError<H::Out, Self::Error>>| format!("Trie lookup error: {}", e);
 
 		TrieDB::new(&eph, &self.root).map_err(map_e)?
@@ -181,7 +182,7 @@ impl<H: Hasher> Backend<H> for TrieBackend<H> {
 	}
 }
 
-impl<H: Hasher> TryIntoTrieBackend<H> for TrieBackend<H> {
+impl<H: Hasher, C: NodeCodec<H>> TryIntoTrieBackend<H, C> for TrieBackend<H> {
 	fn try_into_trie_backend(self) -> Option<TrieBackend<H>> {
 		Some(self)
 	}