Support multi trie in genesis generation (#958)

* Support multi trie in genesis generation

* Fix merge issues

substrate/core/client/src/backend.rs

@@ -18,7 +18,7 @@
 
 use error;
 use primitives::AuthorityId;
-use runtime_primitives::{generic::BlockId, Justification};
+use runtime_primitives::{generic::BlockId, Justification, StorageMap, ChildrenStorageMap};
 use runtime_primitives::traits::{Block as BlockT, NumberFor};
 use state_machine::backend::Backend as StateBackend;
 use state_machine::ChangesTrieStorage as StateChangesTrieStorage;
@@ -50,8 +50,7 @@ impl NewBlockState {
 pub trait BlockImportOperation<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
-
+	H: Hasher<Out=Block::Hash>,
 {
 	/// Associated state backend type.
 	type State: StateBackend<H>;
@@ -73,7 +72,7 @@ where
 	/// Inject storage data into the database.
 	fn update_storage(&mut self, update: <Self::State as StateBackend<H>>::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<()>;
+	fn reset_storage(&mut self, top: StorageMap, children: ChildrenStorageMap) -> error::Result<H::Out>;
 	/// Inject changes trie data into the database.
 	fn update_changes_trie(&mut self, update: MemoryDB<H>) -> error::Result<()>;
 }
@@ -89,7 +88,7 @@ where
 pub trait Backend<Block, H>: Send + Sync
 where
 	Block: BlockT,
-	H: Hasher,
+	H: Hasher<Out=Block::Hash>,
 
 {
 	/// Associated block insertion operation type.
@@ -128,14 +127,12 @@ where
 pub trait LocalBackend<Block, H>: Backend<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
-
+	H: Hasher<Out=Block::Hash>,
 {}
 
 /// Mark for all Backend implementations, that are fetching required state data from remote nodes.
 pub trait RemoteBackend<Block, H>: Backend<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
-
+	H: Hasher<Out=Block::Hash>,
 {}

substrate/core/client/src/block_builder.rs

@@ -25,7 +25,7 @@ use runtime_primitives::generic::BlockId;
 use runtime_api::BlockBuilder as BlockBuilderAPI;
 use {backend, error, Client, CallExecutor};
 use runtime_primitives::ApplyOutcome;
-use primitives::{Blake2Hasher};
+use primitives::{Blake2Hasher, H256};
 use hash_db::Hasher;
 
 /// Utility for building new (valid) blocks from a stream of extrinsics.
@@ -34,7 +34,7 @@ where
 	B: backend::Backend<Block, H> + 'a,
 	E: CallExecutor<Block, H> + Clone + 'a,
 	Block: BlockT,
-	H: Hasher,
+	H: Hasher<Out=Block::Hash>,
 	H::Out: Ord,
 
 {
@@ -50,7 +50,7 @@ impl<'a, B, E, Block> BlockBuilder<'a, B, E, Block, Blake2Hasher>
 where
 	B: backend::Backend<Block, Blake2Hasher> + 'a,
 	E: CallExecutor<Block, Blake2Hasher> + Clone + 'a,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	/// Create a new instance of builder from the given client, building on the latest block.
 	pub fn new(client: &'a Client<B, E, Block>) -> error::Result<Self> {

substrate/core/client/src/call_executor.rs

@@ -24,7 +24,7 @@ use executor::{RuntimeVersion, RuntimeInfo, NativeVersion};
 use hash_db::Hasher;
 use trie::MemoryDB;
 use codec::Decode;
-use primitives::{Blake2Hasher};
+use primitives::{H256, Blake2Hasher};
 use primitives::storage::well_known_keys;
 
 use backend;
@@ -43,7 +43,7 @@ pub struct CallResult {
 pub trait CallExecutor<B, H>
 where
 	B: BlockT,
-	H: Hasher,
+	H: Hasher<Out=B::Hash>,
 	H::Out: Ord,
 
 {
@@ -119,7 +119,7 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
 where
 	B: backend::LocalBackend<Block, Blake2Hasher>,
 	E: CodeExecutor<Blake2Hasher> + RuntimeInfo,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type Error = E::Error;
 

substrate/core/client/src/client.rs

@@ -184,11 +184,10 @@ pub fn new_in_mem<E, Block, S>(
 	executor: E,
 	genesis_storage: S,
 ) -> error::Result<Client<in_mem::Backend<Block, Blake2Hasher>, LocalCallExecutor<in_mem::Backend<Block, Blake2Hasher>, E>, Block>>
-	where
-		E: CodeExecutor<Blake2Hasher> + RuntimeInfo,
-		S: BuildStorage,
-		Block: BlockT,
-		H256: From<Block::Hash>,
+where
+	E: CodeExecutor<Blake2Hasher> + RuntimeInfo,
+	S: BuildStorage,
+	Block: BlockT<Hash=H256>,
 {
 	new_with_backend(Arc::new(in_mem::Backend::new()), executor, genesis_storage)
 }
@@ -200,12 +199,11 @@ pub fn new_with_backend<B, E, Block, S>(
 	executor: E,
 	build_genesis_storage: S,
 ) -> error::Result<Client<B, LocalCallExecutor<B, E>, Block>>
-	where
-		E: CodeExecutor<Blake2Hasher> + RuntimeInfo,
-		S: BuildStorage,
-		Block: BlockT,
-		H256: From<Block::Hash>,
-		B: backend::LocalBackend<Block, Blake2Hasher>
+where
+	E: CodeExecutor<Blake2Hasher> + RuntimeInfo,
+	S: BuildStorage,
+	Block: BlockT<Hash=H256>,
+	B: backend::LocalBackend<Block, Blake2Hasher>
 {
 	let call_executor = LocalCallExecutor::new(backend.clone(), executor);
 	Client::new(backend, call_executor, build_genesis_storage, ExecutionStrategy::NativeWhenPossible, ExecutionStrategy::NativeWhenPossible)
@@ -214,7 +212,7 @@ pub fn new_with_backend<B, E, Block, S>(
 impl<B, E, Block> Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher>,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	/// Creates new Substrate Client with given blockchain and code executor.
 	pub fn new<S: BuildStorage>(
@@ -225,11 +223,12 @@ impl<B, E, Block> Client<B, E, Block> where
 		api_execution_strategy: ExecutionStrategy,
 	) -> error::Result<Self> {
 		if backend.blockchain().header(BlockId::Number(Zero::zero()))?.is_none() {
-			let genesis_storage = build_genesis_storage.build_storage()?;
-			let genesis_block = genesis::construct_genesis_block::<Block>(&genesis_storage);
-			info!("Initialising Genesis block/state (state: {}, header-hash: {})", genesis_block.header().state_root(), genesis_block.header().hash());
+			let (genesis_storage, children_genesis_storage) = build_genesis_storage.build_storage()?;
 			let mut op = backend.begin_operation(BlockId::Hash(Default::default()))?;
-			op.reset_storage(genesis_storage.into_iter())?;
+			let state_root = op.reset_storage(genesis_storage, children_genesis_storage)?;
+
+			let genesis_block = genesis::construct_genesis_block::<Block>(state_root.into());
+			info!("Initialising Genesis block/state (state: {}, header-hash: {})", genesis_block.header().state_root(), genesis_block.header().hash());
 			op.set_block_data(
 				genesis_block.deconstruct().0,
 				Some(vec![]),
@@ -895,7 +894,7 @@ impl<B, E, Block> Client<B, E, Block> where
 impl<B, E, Block> consensus::BlockImport<Block> for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher> + Clone,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type Error = Error;
 
@@ -961,7 +960,7 @@ impl<B, E, Block> consensus::BlockImport<Block> for Client<B, E, Block> where
 impl<B, E, Block> consensus::Authorities<Block> for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher> + Clone,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type Error = Error;
 	fn authorities(&self, at: &BlockId<Block>) -> Result<Vec<AuthorityId>, Self::Error> {
@@ -972,7 +971,7 @@ impl<B, E, Block> consensus::Authorities<Block> for Client<B, E, Block> where
 impl<B, E, Block> CurrentHeight for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher> + Clone,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type BlockNumber = <Block::Header as HeaderT>::Number;
 	fn current_height(&self) -> Self::BlockNumber {
@@ -983,7 +982,7 @@ impl<B, E, Block> CurrentHeight for Client<B, E, Block> where
 impl<B, E, Block> BlockNumberToHash for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher> + Clone,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type BlockNumber = <Block::Header as HeaderT>::Number;
 	type Hash = Block::Hash;
@@ -996,7 +995,7 @@ impl<B, E, Block> BlockNumberToHash for Client<B, E, Block> where
 impl<B, E, Block> BlockchainEvents<Block> for Client<B, E, Block>
 where
 	E: CallExecutor<Block, Blake2Hasher>,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	/// Get block import event stream.
 	fn import_notification_stream(&self) -> ImportNotifications<Block> {
@@ -1021,18 +1020,17 @@ impl<B, E, Block> ChainHead<Block> for Client<B, E, Block>
 where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher>,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	fn best_block_header(&self) -> error::Result<<Block as BlockT>::Header> {
 		Client::best_block_header(self)
 	}
 }
 
-impl<B, E, Block> BlockBody<Block> for Client<B, E, Block>
-	where
-		B: backend::Backend<Block, Blake2Hasher>,
-		E: CallExecutor<Block, Blake2Hasher>,
-		Block: BlockT,
+impl<B, E, Block> BlockBody<Block> for Client<B, E, Block> where
+	B: backend::Backend<Block, Blake2Hasher>,
+	E: CallExecutor<Block, Blake2Hasher>,
+	Block: BlockT<Hash=H256>,
 {
 	fn block_body(&self, id: &BlockId<Block>) -> error::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
 		self.body(id)
@@ -1042,7 +1040,7 @@ impl<B, E, Block> BlockBody<Block> for Client<B, E, Block>
 impl<B, E, Block> api::Core<Block, AuthorityId> for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher>,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type Error = Error;
 
@@ -1062,7 +1060,7 @@ impl<B, E, Block> api::Core<Block, AuthorityId> for Client<B, E, Block> where
 impl<B, E, Block> api::Metadata<Block, Vec<u8>> for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher>,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type Error = Error;
 
@@ -1074,7 +1072,7 @@ impl<B, E, Block> api::Metadata<Block, Vec<u8>> for Client<B, E, Block> where
 impl<B, E, Block> api::BlockBuilder<Block> for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher>,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type Error = Error;
 	type OverlayedChanges = OverlayedChanges;
@@ -1128,7 +1126,7 @@ impl<B, E, Block> api::BlockBuilder<Block> for Client<B, E, Block> where
 impl<B, E, Block> api::TaggedTransactionQueue<Block> for Client<B, E, Block> where
 	B: backend::Backend<Block, Blake2Hasher>,
 	E: CallExecutor<Block, Blake2Hasher>,
-	Block: BlockT,
+	Block: BlockT<Hash=H256>,
 {
 	type Error = Error;
 

substrate/core/client/src/error.rs

@@ -70,6 +70,12 @@ error_chain! {
 			display("On-chain runtime does not specify version"),
 		}
 
+		/// Genesis config is invalid.
+		GenesisInvalid {
+			description("Genesis config error"),
+			display("Genesis config provided is invalid"),
+		}
+
 		/// Bad justification for header.
 		BadJustification(h: String) {
 			description("bad justification for header"),

substrate/core/client/src/genesis.rs

@@ -17,15 +17,13 @@
 //! Tool for creating the genesis block.
 
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, Hash as HashT, Zero};
-use runtime_primitives::StorageMap;
 
 /// Create a genesis block, given the initial storage.
 pub fn construct_genesis_block<
 	Block: BlockT
 > (
-	storage: &StorageMap
+	state_root: Block::Hash
 ) -> Block {
-	let state_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(storage.clone().into_iter());
 	let extrinsics_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(::std::iter::empty::<(&[u8], &[u8])>());
 	Block::new(
 		<<Block as BlockT>::Header as HeaderT>::new(
@@ -50,6 +48,7 @@ mod tests {
 	use test_client;
 	use test_client::runtime::genesismap::{GenesisConfig, additional_storage_with_genesis};
 	use test_client::runtime::{Hash, Transfer, Block, BlockNumber, Header, Digest, Extrinsic};
+	use runtime_primitives::traits::BlakeTwo256;
 	use primitives::{Blake2Hasher, ed25519::{Public, Pair}};
 
 	native_executor_instance!(Executor, test_client::runtime::api::dispatch, test_client::runtime::native_version, include_bytes!("../../test-runtime/wasm/target/wasm32-unknown-unknown/release/substrate_test_runtime.compact.wasm"));
@@ -144,7 +143,8 @@ mod tests {
 		let mut storage = GenesisConfig::new_simple(
 			vec![Keyring::One.to_raw_public().into(), Keyring::Two.to_raw_public().into()], 1000
 		).genesis_map();
-		let block = construct_genesis_block::<Block>(&storage);
+		let state_root = BlakeTwo256::trie_root(storage.clone().into_iter());
+		let block = construct_genesis_block::<Block>(state_root);
 		let genesis_hash = block.header.hash();
 		storage.extend(additional_storage_with_genesis(&block).into_iter());
 
@@ -168,7 +168,8 @@ mod tests {
 		let mut storage = GenesisConfig::new_simple(
 			vec![Keyring::One.to_raw_public().into(), Keyring::Two.to_raw_public().into()], 1000
 		).genesis_map();
-		let block = construct_genesis_block::<Block>(&storage);
+		let state_root = BlakeTwo256::trie_root(storage.clone().into_iter());
+		let block = construct_genesis_block::<Block>(state_root);
 		let genesis_hash = block.header.hash();
 		storage.extend(additional_storage_with_genesis(&block).into_iter());
 
@@ -193,7 +194,8 @@ mod tests {
 		let mut storage = GenesisConfig::new_simple(
 			vec![Keyring::One.to_raw_public().into(), Keyring::Two.to_raw_public().into()], 68
 		).genesis_map();
-		let block = construct_genesis_block::<Block>(&storage);
+		let state_root = BlakeTwo256::trie_root(storage.clone().into_iter());
+		let block = construct_genesis_block::<Block>(state_root);
 		let genesis_hash = block.header.hash();
 		storage.extend(additional_storage_with_genesis(&block).into_iter());
 

substrate/core/client/src/in_mem.rs

@@ -22,13 +22,13 @@ use parking_lot::RwLock;
 use error;
 use backend::{self, NewBlockState};
 use light;
-use primitives::AuthorityId;
+use primitives::{AuthorityId, storage::well_known_keys};
 use runtime_primitives::generic::BlockId;
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, Zero,
 	NumberFor, As, Digest, DigestItem};
-use runtime_primitives::Justification;
+use runtime_primitives::{Justification, StorageMap, ChildrenStorageMap};
 use blockchain::{self, BlockStatus, HeaderBackend};
-use state_machine::backend::{Backend as StateBackend, InMemory};
+use state_machine::backend::{Backend as StateBackend, InMemory, Consolidate};
 use state_machine::InMemoryChangesTrieStorage;
 use hash_db::Hasher;
 use heapsize::HeapSizeOf;
@@ -361,9 +361,9 @@ pub struct BlockImportOperation<Block: BlockT, H: Hasher> {
 impl<Block, H> backend::BlockImportOperation<Block, H> for BlockImportOperation<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
+	H: Hasher<Out=Block::Hash>,
 
-	H::Out: HeapSizeOf,
+	H::Out: HeapSizeOf + Ord,
 {
 	type State = InMemory<H>;
 
@@ -400,9 +400,31 @@ where
 		Ok(())
 	}
 
-	fn reset_storage<I: Iterator<Item=(Vec<u8>, Vec<u8>)>>(&mut self, iter: I) -> error::Result<()> {
-		self.new_state = Some(InMemory::from(iter.collect::<HashMap<_, _>>()));
-		Ok(())
+	fn reset_storage(&mut self, mut top: StorageMap, children: ChildrenStorageMap) -> error::Result<H::Out> {
+		if top.iter().any(|(k, _)| well_known_keys::is_child_storage_key(k)) {
+			return Err(error::ErrorKind::GenesisInvalid.into());
+		}
+
+		let mut transaction: Vec<(Option<Vec<u8>>, Vec<u8>, Option<Vec<u8>>)> = Default::default();
+
+		for (child_key, child_map) in children {
+			if !well_known_keys::is_child_storage_key(&child_key) {
+				return Err(error::ErrorKind::GenesisInvalid.into());
+			}
+
+			let (root, is_default, update) = self.old_state.child_storage_root(&child_key, child_map.into_iter().map(|(k, v)| (k, Some(v))));
+			transaction.consolidate(update);
+
+			if !is_default {
+				top.insert(child_key, root);
+			}
+		}
+
+		let (root, update) = self.old_state.storage_root(top.into_iter().map(|(k, v)| (k, Some(v))));
+		transaction.consolidate(update);
+
+		self.new_state = Some(InMemory::from(transaction));
+		Ok(root)
 	}
 }
 
@@ -410,9 +432,8 @@ where
 pub struct Backend<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
-
-	H::Out: HeapSizeOf + From<Block::Hash>,
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
 {
 	states: RwLock<HashMap<Block::Hash, InMemory<H>>>,
 	changes_trie_storage: InMemoryChangesTrieStorage<H>,
@@ -423,9 +444,8 @@ where
 impl<Block, H> Backend<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
-
-	H::Out: HeapSizeOf + From<Block::Hash>,
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
 {
 	/// Create a new instance of in-mem backend.
 	pub fn new() -> Backend<Block, H> {
@@ -441,8 +461,8 @@ where
 impl<Block, H> backend::Backend<Block, H> for Backend<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
-	H::Out: HeapSizeOf + From<Block::Hash>,
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
 {
 	type BlockImportOperation = BlockImportOperation<Block, H>;
 	type Blockchain = Blockchain<Block>;
@@ -533,8 +553,8 @@ where
 impl<Block, H> backend::LocalBackend<Block, H> for Backend<Block, H>
 where
 	Block: BlockT,
-	H: Hasher,
-	H::Out: HeapSizeOf + From<Block::Hash>,
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
 {}
 
 impl<Block: BlockT> Cache<Block> {

substrate/core/client/src/light/backend.rs

@@ -22,10 +22,11 @@ use futures::{Future, IntoFuture};
 use parking_lot::RwLock;
 
 use primitives::AuthorityId;
-use runtime_primitives::{generic::BlockId, Justification};
+use runtime_primitives::{generic::BlockId, Justification, StorageMap, ChildrenStorageMap};
 use state_machine::{Backend as StateBackend, InMemoryChangesTrieStorage, TrieBackend};
 use runtime_primitives::traits::{Block as BlockT, NumberFor};
 
+use in_mem;
 use backend::{Backend as ClientBackend, BlockImportOperation, RemoteBackend, NewBlockState};
 use blockchain::HeaderBackend as BlockchainHeaderBackend;
 use error::{Error as ClientError, ErrorKind as ClientErrorKind, Result as ClientResult};
@@ -72,9 +73,8 @@ impl<S, F, Block, H> ClientBackend<Block, H> for Backend<S, F> where
 	Block: BlockT,
 	S: BlockchainStorage<Block>,
 	F: Fetcher<Block>,
-	H: Hasher,
-
-	H::Out: HeapSizeOf,
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
 {
 	type BlockImportOperation = ImportOperation<Block, S, F>;
 	type Blockchain = Blockchain<S, F>;
@@ -143,9 +143,8 @@ where
 	Block: BlockT,
 	S: BlockchainStorage<Block>,
 	F: Fetcher<Block>,
-	H: Hasher,
-	H::Out: HeapSizeOf,
-
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
 {}
 
 impl<S, F, Block, H> BlockImportOperation<Block, H> for ImportOperation<Block, S, F>
@@ -153,8 +152,8 @@ where
 	Block: BlockT,
 	F: Fetcher<Block>,
 	S: BlockchainStorage<Block>,
-	H: Hasher,
-
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
 {
 	type State = OnDemandState<Block, S, F>;
 
@@ -189,19 +188,19 @@ where
 		Ok(())
 	}
 
-	fn reset_storage<I: Iterator<Item=(Vec<u8>, Vec<u8>)>>(&mut self, _iter: I) -> ClientResult<()> {
-		// we're not storing anything locally => ignore changes
-		Ok(())
+	fn reset_storage(&mut self, top: StorageMap, children: ChildrenStorageMap) -> ClientResult<H::Out> {
+		let in_mem = in_mem::Backend::<Block, H>::new();
+		let mut op = in_mem.begin_operation(BlockId::Hash(Default::default()))?;
+		op.reset_storage(top, children)
 	}
 }
 
 impl<Block, S, F, H> StateBackend<H> for OnDemandState<Block, S, F>
-	where
-		Block: BlockT,
-		S: BlockchainStorage<Block>,
-		F: Fetcher<Block>,
-		H: Hasher,
-
+where
+	Block: BlockT,
+	S: BlockchainStorage<Block>,
+	F: Fetcher<Block>,
+	H: Hasher<Out=Block::Hash>,
 {
 	type Error = ClientError;
 	type Transaction = ();
@@ -246,11 +245,11 @@ impl<Block, S, F, H> StateBackend<H> for OnDemandState<Block, S, F>
 		(H::Out::default(), ())
 	}
 
-	fn child_storage_root<I>(&self, _key: &[u8], _delta: I) -> (Vec<u8>, Self::Transaction)
+	fn child_storage_root<I>(&self, _key: &[u8], _delta: I) -> (Vec<u8>, bool, Self::Transaction)
 	where
 		I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>
 	{
-		(H::Out::default().as_ref().to_vec(), ())
+		(H::Out::default().as_ref().to_vec(), true, ())
 	}
 
 	fn pairs(&self) -> Vec<(Vec<u8>, Vec<u8>)> {

substrate/core/client/src/light/call_executor.rs

@@ -66,9 +66,8 @@ where
 	Block: BlockT,
 	B: ChainBackend<Block>,
 	F: Fetcher<Block>,
-	H: Hasher,
-	H::Out: Ord,
-
+	H: Hasher<Out=Block::Hash>,
+	Block::Hash: Ord,
 {
 	type Error = ClientError;
 
@@ -134,7 +133,7 @@ pub fn check_execution_proof<Header, E, H>(
 		E: CodeExecutor<H>,
 		H: Hasher,
 		H::Out: Ord + HeapSizeOf,
-	
+
 {
 	let local_state_root = request.header.state_root();
 	let mut root: H::Out = Default::default();

substrate/core/client/src/light/mod.rs

@@ -23,7 +23,7 @@ pub mod fetcher;
 
 use std::sync::Arc;
 
-use primitives::{Blake2Hasher};
+use primitives::{H256, Blake2Hasher};
 use runtime_primitives::BuildStorage;
 use runtime_primitives::traits::Block as BlockT;
 use state_machine::{CodeExecutor, ExecutionStrategy};
@@ -53,11 +53,12 @@ pub fn new_light<B, S, F, GS>(
 	fetcher: Arc<F>,
 	genesis_storage: GS,
 ) -> ClientResult<Client<Backend<S, F>, RemoteCallExecutor<Blockchain<S, F>, F, Blake2Hasher>, B>>
-	where
-		B: BlockT,
-		S: BlockchainStorage<B>,
-		F: Fetcher<B>,
-		GS: BuildStorage,
+where
+	B: BlockT<Hash=H256>,
+	S: BlockchainStorage<B>,
+	F: Fetcher<B>,
+	GS: BuildStorage,
+
 {
 	let executor = RemoteCallExecutor::new(backend.blockchain().clone(), fetcher);
 	Client::new(backend, executor, genesis_storage, ExecutionStrategy::NativeWhenPossible, ExecutionStrategy::NativeWhenPossible)
@@ -70,7 +71,7 @@ pub fn new_fetch_checker<E, H>(
 	where
 		E: CodeExecutor<H>,
 		H: Hasher,
-	
+
 {
 	LightDataChecker::new(executor)
 }