WIP make client generic

substrate/client/Cargo.toml

@@ -23,6 +23,9 @@ substrate-runtime-primitives = { path = "../runtime/primitives" }
 substrate-state-machine = { path = "../state-machine" }
 substrate-keyring = { path = "../../substrate/keyring" }
 substrate-telemetry = { path = "../telemetry" }
+hashdb = { git = "https://github.com/paritytech/parity-common" }
+patricia-trie = { git = "https://github.com/paritytech/parity-common" }
+rlp = { git = "https://github.com/paritytech/parity-common" }
 
 [dev-dependencies]
 substrate-test-client = { path = "../test-client" }

substrate/client/db/Cargo.toml

@@ -8,7 +8,7 @@ parking_lot = "0.4"
 log = "0.3"
 kvdb = { git = "https://github.com/paritytech/parity-common" }
 kvdb-rocksdb = { git = "https://github.com/paritytech/parity-common" }
-ethereum-types = "0.3"
+# ethereum-types = "0.3"
 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/client/src/backend.rs

@@ -22,11 +22,18 @@ use runtime_primitives::bft::Justification;
 use runtime_primitives::generic::BlockId;
 use runtime_primitives::traits::{Block as BlockT, NumberFor};
 use state_machine::backend::Backend as StateBackend;
+use patricia_trie::NodeCodec;
+use hashdb::Hasher;
 
 /// Block insertion operation. Keeps hold if the inserted block state and data.
-pub trait BlockImportOperation<Block: BlockT> {
+pub trait BlockImportOperation<Block, H, C>
+where
+	Block: BlockT,
+	H: Hasher,
+	C: NodeCodec<H>,
+{
 	/// Associated state backend type.
-	type State: StateBackend;
+	type State: StateBackend<H, C>;
 
 	/// Returns pending state. Returns None for backends with locally-unavailable state data.
 	fn state(&self) -> error::Result<Option<&Self::State>>;
@@ -43,7 +50,7 @@ pub trait BlockImportOperation<Block: BlockT> {
 	/// has been used to check justification of this block).
 	fn update_authorities(&mut self, authorities: Vec<AuthorityId>);
 	/// Inject storage data into the database.
-	fn update_storage(&mut self, update: <Self::State as StateBackend>::Transaction) -> error::Result<()>;
+	fn update_storage(&mut self, update: <Self::State as StateBackend<H, C>>::Transaction) -> error::Result<()>;
 	/// Inject storage data into the database replacing any existing data.
 	fn reset_storage<I: Iterator<Item=(Vec<u8>, Vec<u8>)>>(&mut self, iter: I) -> error::Result<()>;
 }
@@ -56,13 +63,18 @@ pub trait BlockImportOperation<Block: BlockT> {
 ///
 /// The same applies for live `BlockImportOperation`s: while an import operation building on a parent `P`
 /// is alive, the state for `P` should not be pruned.
-pub trait Backend<Block: BlockT>: Send + Sync {
+pub trait Backend<Block, H, C>: Send + Sync
+where
+	Block: BlockT,
+	H: Hasher,
+	C: NodeCodec<H>,
+{
 	/// Associated block insertion operation type.
-	type BlockImportOperation: BlockImportOperation<Block>;
+	type BlockImportOperation: BlockImportOperation<Block, H, C>;
 	/// Associated blockchain backend type.
 	type Blockchain: ::blockchain::Backend<Block>;
 	/// Associated state backend type.
-	type State: StateBackend;
+	type State: StateBackend<H, C>;
 
 	/// Begin a new block insertion transaction with given parent block id.
 	/// When constructing the genesis, this is called with all-zero hash.
@@ -79,7 +91,17 @@ pub trait Backend<Block: BlockT>: Send + Sync {
 }
 
 /// Mark for all Backend implementations, that are making use of state data, stored locally.
-pub trait LocalBackend<Block: BlockT>: Backend<Block> {}
+pub trait LocalBackend<Block, H, C>: Backend<Block, H, C>
+where
+	Block: BlockT,
+	H: Hasher,
+	C: NodeCodec<H>,
+{}
 
 /// Mark for all Backend implementations, that are fetching required state data from remote nodes.
-pub trait RemoteBackend<Block: BlockT>: Backend<Block> {}
+pub trait RemoteBackend<Block, H, C>: Backend<Block, H, C>
+where
+	Block: BlockT,
+	H: Hasher,
+	C: NodeCodec<H>,
+{}

substrate/client/src/block_builder.rs

@@ -23,12 +23,18 @@ use runtime_primitives::traits::{Header as HeaderT, Hash, Block as BlockT, One,
 use runtime_primitives::generic::BlockId;
 use {backend, error, Client, CallExecutor};
 use runtime_primitives::{ApplyResult, ApplyOutcome};
+use patricia_trie::NodeCodec;
+use hashdb::Hasher;
+use rlp::Encodable;
 
 /// Utility for building new (valid) blocks from a stream of extrinsics.
-pub struct BlockBuilder<B, E, Block> where
-	B: backend::Backend<Block>,
-	E: CallExecutor<Block> + Clone,
+pub struct BlockBuilder<B, E, Block, H, C>
+where
+	B: backend::Backend<Block, H, C>,
+	E: CallExecutor<Block, H, C> + Clone,
 	Block: BlockT,
+	H: Hasher,
+	C: NodeCodec<H>,
 {
 	header: <Block as BlockT>::Header,
 	extrinsics: Vec<<Block as BlockT>::Extrinsic>,
@@ -37,10 +43,14 @@ pub struct BlockBuilder<B, E, Block> where
 	changes: state_machine::OverlayedChanges,
 }
 
-impl<B, E, Block> BlockBuilder<B, E, Block> where
-	B: backend::Backend<Block>,
-	E: CallExecutor<Block> + Clone,
+impl<B, E, Block, H, C> BlockBuilder<B, E, Block, H, C>
+where
+	B: backend::Backend<Block, H, C>,
+	E: CallExecutor<Block, H, C> + Clone,
 	Block: BlockT,
+	H: Hasher,
+	H::Out: Encodable + Ord,
+	C: NodeCodec<H>,
 {
 	/// Create a new instance of builder from the given client, building on the latest block.
 	pub fn new(client: &Client<B, E, Block>) -> error::Result<Self> {

substrate/client/src/call_executor.rs

@@ -15,12 +15,16 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::sync::Arc;
+use std::cmp::Ord;
 use runtime_primitives::generic::BlockId;
 use runtime_primitives::traits::Block as BlockT;
-use state_machine::{self, OverlayedChanges, Ext, 
+use state_machine::{self, OverlayedChanges, Ext,
 	CodeExecutor, ExecutionManager, native_when_possible};
 use runtime_io::Externalities;
 use executor::{RuntimeVersion, RuntimeInfo};
+use patricia_trie::NodeCodec;
+use hashdb::Hasher;
+use rlp::Encodable;
 
 use backend;
 use error;
@@ -35,7 +39,13 @@ pub struct CallResult {
 }
 
 /// Method call executor.
-pub trait CallExecutor<B: BlockT> {
+pub trait CallExecutor<B, H, C>
+where
+	B: BlockT,
+	H: Hasher,
+	H::Out: Ord + Encodable,
+	C: NodeCodec<H>,
+{
 	/// Externalities error type.
 	type Error: state_machine::Error;
 
@@ -57,7 +67,7 @@ pub trait CallExecutor<B: BlockT> {
 	///
 	/// No changes are made.
 	fn call_at_state<
-		S: state_machine::Backend,
+		S: state_machine::Backend<H, C>,
 		F: FnOnce(Result<Vec<u8>, Self::Error>, Result<Vec<u8>, Self::Error>) -> Result<Vec<u8>, Self::Error>,
 	>(&self,
 		state: &S,
@@ -70,7 +80,7 @@ pub trait CallExecutor<B: BlockT> {
 	/// Execute a call to a contract on top of given state, gathering execution proof.
 	///
 	/// No changes are made.
-	fn prove_at_state<S: state_machine::Backend>(&self,
+	fn prove_at_state<S: state_machine::Backend<H, C>>(&self,
 		state: S,
 		overlay: &mut OverlayedChanges,
 		method: &str,
@@ -104,11 +114,14 @@ impl<B, E> Clone for LocalCallExecutor<B, E> where E: Clone {
 	}
 }
 
-impl<B, E, Block> CallExecutor<Block> for LocalCallExecutor<B, E>
-	where
-		B: backend::LocalBackend<Block>,
-		E: CodeExecutor + RuntimeInfo,
-		Block: BlockT,
+impl<B, E, Block, H, C> CallExecutor<Block, H, C> for LocalCallExecutor<B, E>
+where
+	B: backend::LocalBackend<Block, H, C>,
+	E: CodeExecutor<H> + RuntimeInfo,
+	Block: BlockT,
+	H: Hasher,
+	H::Out: Encodable + Ord,
+	C: NodeCodec<H>,
 {
 	type Error = E::Error;
 
@@ -140,7 +153,7 @@ impl<B, E, Block> CallExecutor<Block> for LocalCallExecutor<B, E>
 	}
 
 	fn call_at_state<
-		S: state_machine::Backend,
+		S: state_machine::Backend<H, C>,
 		F: FnOnce(Result<Vec<u8>, Self::Error>, Result<Vec<u8>, Self::Error>) -> Result<Vec<u8>, Self::Error>,
 	>(&self,
 		state: &S,
@@ -159,7 +172,7 @@ impl<B, E, Block> CallExecutor<Block> for LocalCallExecutor<B, E>
 		).map_err(Into::into)
 	}
 
-	fn prove_at_state<S: state_machine::Backend>(&self,
+	fn prove_at_state<S: state_machine::Backend<H, C>>(&self,
 		state: S,
 		changes: &mut OverlayedChanges,
 		method: &str,

substrate/client/src/client.rs

@@ -17,6 +17,7 @@
 //! Substrate Client
 
 use std::sync::Arc;
+use std::cmp::Ord;
 use futures::sync::mpsc;
 use parking_lot::{Mutex, RwLock};
 use primitives::AuthorityId;
@@ -33,6 +34,9 @@ use call_executor::{CallExecutor, LocalCallExecutor};
 use executor::{RuntimeVersion, RuntimeInfo};
 use notifications::{StorageNotifications, StorageEventStream};
 use {error, in_mem, block_builder, runtime_io, bft, genesis};
+use patricia_trie::NodeCodec;
+use hashdb::Hasher;
+use rlp::Encodable;
 
 /// Type that implements `futures::Stream` of block import events.
 pub type BlockchainEventStream<Block> = mpsc::UnboundedReceiver<BlockImportNotification<Block>>;
@@ -151,24 +155,30 @@ impl<Block: BlockT> JustifiedHeader<Block> {
 }
 
 /// Create an instance of in-memory client.
-pub fn new_in_mem<E, Block, S>(
+pub fn new_in_mem<E, Block, S, H, C>(
 	executor: E,
 	genesis_storage: S,
-) -> error::Result<Client<in_mem::Backend<Block>, LocalCallExecutor<in_mem::Backend<Block>, E>, Block>>
+) -> error::Result<Client<in_mem::Backend<Block, H, C>, LocalCallExecutor<in_mem::Backend<Block, H, C>, E>, Block>>
 	where
-		E: CodeExecutor + RuntimeInfo,
+		E: CodeExecutor<H> + RuntimeInfo,
 		S: BuildStorage,
 		Block: BlockT,
+		H: Hasher,
+		H::Out: Encodable + Ord,
+		C: NodeCodec<H> + Send + Sync,
 {
 	let backend = Arc::new(in_mem::Backend::new());
 	let executor = LocalCallExecutor::new(backend.clone(), executor);
 	Client::new(backend, executor, genesis_storage, ExecutionStrategy::NativeWhenPossible)
 }
 
-impl<B, E, Block> Client<B, E, Block> where
-	B: backend::Backend<Block>,
-	E: CallExecutor<Block>,
+impl<B, E, Block, H, C> Client<B, E, Block> where
+	B: backend::Backend<Block, H, C>,
+	E: CallExecutor<Block, H, C>,
 	Block: BlockT,
+	H: Hasher,
+	H::Out: Encodable + Ord,
+	C: NodeCodec<H>,
 {
 	/// Creates new Substrate Client with given blockchain and code executor.
 	pub fn new<S: BuildStorage>(
@@ -267,12 +277,12 @@ impl<B, E, Block> Client<B, E, Block> where
 	}
 
 	/// Create a new block, built on the head of the chain.
-	pub fn new_block(&self) -> error::Result<block_builder::BlockBuilder<B, E, Block>> where E: Clone {
+	pub fn new_block(&self) -> error::Result<block_builder::BlockBuilder<B, E, Block, H, C>> where E: Clone {
 		block_builder::BlockBuilder::new(self)
 	}
 
 	/// Create a new block, built on top of `parent`.
-	pub fn new_block_at(&self, parent: &BlockId<Block>) -> error::Result<block_builder::BlockBuilder<B, E, Block>> where E: Clone {
+	pub fn new_block_at(&self, parent: &BlockId<Block>) -> error::Result<block_builder::BlockBuilder<B, E, Block, H, C>> where E: Clone {
 		block_builder::BlockBuilder::at_block(parent, &self)
 	}
 
@@ -485,11 +495,14 @@ impl<B, E, Block> Client<B, E, Block> where
 	}
 }
 
-impl<B, E, Block> bft::BlockImport<Block> for Client<B, E, Block>
+impl<B, E, Block, H, C> bft::BlockImport<Block> for Client<B, E, Block>
 	where
-		B: backend::Backend<Block>,
-		E: CallExecutor<Block>,
+		B: backend::Backend<Block, H, C>,
+		E: CallExecutor<Block, H, C>,
 		Block: BlockT,
+		H: Hasher,
+		H::Out: Encodable + Ord,
+		C: NodeCodec<H>,
 {
 	fn import_block(
 		&self,
@@ -508,11 +521,14 @@ impl<B, E, Block> bft::BlockImport<Block> for Client<B, E, Block>
 	}
 }
 
-impl<B, E, Block> bft::Authorities<Block> for Client<B, E, Block>
+impl<B, E, Block, H, C> bft::Authorities<Block> for Client<B, E, Block>
 	where
-		B: backend::Backend<Block>,
-		E: CallExecutor<Block>,
+		B: backend::Backend<Block, H, C>,
+		E: CallExecutor<Block, H, C>,
 		Block: BlockT,
+		H: Hasher,
+		H::Out: Encodable + Ord,
+		C: NodeCodec<H>,
 {
 	fn authorities(&self, at: &BlockId<Block>) -> Result<Vec<AuthorityId>, bft::Error> {
 		let on_chain_version: Result<_, bft::Error> = self.runtime_version_at(at)
@@ -531,10 +547,12 @@ impl<B, E, Block> bft::Authorities<Block> for Client<B, E, Block>
 	}
 }
 
-impl<B, E, Block> BlockchainEvents<Block> for Client<B, E, Block>
+impl<B, E, Block, H, C> BlockchainEvents<Block> for Client<B, E, Block>
 	where
-		E: CallExecutor<Block>,
+		E: CallExecutor<Block, H, C>,
 		Block: BlockT,
+		H: Hasher,
+		C: NodeCodec<H>,
 {
 	/// Get block import event stream.
 	fn import_notification_stream(&self) -> BlockchainEventStream<Block> {
@@ -549,11 +567,14 @@ impl<B, E, Block> BlockchainEvents<Block> for Client<B, E, Block>
 	}
 }
 
-impl<B, E, Block> ChainHead<Block> for Client<B, E, Block>
+impl<B, E, Block, H, C> ChainHead<Block> for Client<B, E, Block>
 	where
-		B: backend::Backend<Block>,
-		E: CallExecutor<Block>,
+		B: backend::Backend<Block, H, C>,
+		E: CallExecutor<Block, H, C>,
 		Block: BlockT,
+		H: Hasher,
+		H::Out: Encodable + Ord,
+		C: NodeCodec<H>,
 {
 	fn best_block_header(&self) -> error::Result<<Block as BlockT>::Header> {
 		Client::best_block_header(self)