Remove requirement on Hash = H256, make Proposer return StorageChanges and Proof (#3860)

* Extend `Proposer` to optionally generate a proof of the proposal

* Something

* Refactor sr-api to not depend on client anymore

* Fix benches

* Apply suggestions from code review

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Apply suggestions from code review

* Introduce new `into_storage_changes` function

* Switch to runtime api for `execute_block` and don't require `H256`
anywhere in the code

* Put the `StorageChanges` into the `Proposal`

* Move the runtime api error to its own trait

* Adds `StorageTransactionCache` to the runtime api

This requires that we add `type NodeBlock = ` to the
`impl_runtime_apis!` macro to work around some bugs in rustc :(

* Remove `type NodeBlock` and switch to a "better" hack

* Start using the transaction cache from the runtime api

* Make it compile

* Move `InMemory` to its own file

* Make all tests work again

* Return block, storage_changes and proof from Blockbuilder::bake()

* Make sure that we use/set `storage_changes` when possible

* Add test

* Fix deadlock

* Remove accidentally added folders

* Introduce `RecordProof` as argument type to be more explicit

* Update client/src/client.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Update primitives/state-machine/src/ext.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Integrates review feedback

* Remove `unsafe` usage

* Update client/block-builder/src/lib.rs

Co-Authored-By: Benjamin Kampmann <ben@gnunicorn.org>

* Update client/src/call_executor.rs

* Bump versions

Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com>
Co-authored-by: Benjamin Kampmann <ben.kampmann@googlemail.com>

substrate/client/rpc/src/author/mod.rs

@@ -34,9 +34,9 @@ use futures::future::{ready, FutureExt, TryFutureExt};
 use sc_rpc_api::Subscriptions;
 use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
 use codec::{Encode, Decode};
-use sp_core::{Bytes, Blake2Hasher, H256, traits::BareCryptoStorePtr};
-use sp_api::ConstructRuntimeApi;
-use sp_runtime::{generic, traits::{self, ProvideRuntimeApi}};
+use sp_core::{Bytes, traits::BareCryptoStorePtr};
+use sp_api::ProvideRuntimeApi;
+use sp_runtime::{generic, traits};
 use sp_transaction_pool::{
 	TransactionPool, InPoolTransaction, TransactionStatus,
 	BlockHash, TxHash, TransactionFor, error::IntoPoolError,
@@ -76,15 +76,18 @@ impl<B, E, P, Block: traits::Block, RA> Author<B, E, P, Block, RA> {
 	}
 }
 
-impl<B, E, P, Block, RA> AuthorApi<Block::Hash, Block::Hash> for Author<B, E, P, Block, RA> where
-	Block: traits::Block<Hash=H256>,
-	B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-	E: sc_client_api::CallExecutor<Block, Blake2Hasher> + Clone + Send + Sync + 'static,
-	P: TransactionPool<Block=Block, Hash=Block::Hash> + Sync + Send + 'static,
-	RA: ConstructRuntimeApi<Block, Client<B, E, Block, RA>> + Send + Sync + 'static,
-	Client<B, E, Block, RA>: ProvideRuntimeApi,
-	<Client<B, E, Block, RA> as ProvideRuntimeApi>::Api:
-		SessionKeys<Block, Error = ClientError>,
+impl<B, E, P, RA> AuthorApi<TxHash<P>, BlockHash<P>>
+	for Author<B, E, P, <P as TransactionPool>::Block, RA>
+where
+	B: sc_client_api::backend::Backend<<P as TransactionPool>::Block> + Send + Sync + 'static,
+	E: sc_client::CallExecutor<<P as TransactionPool>::Block> + Send + Sync + 'static,
+	P: TransactionPool + Sync + Send + 'static,
+	P::Block: traits::Block,
+	P::Error: 'static,
+	RA: Send + Sync + 'static,
+	Client<B, E, P::Block, RA>: ProvideRuntimeApi<P::Block>,
+	<Client<B, E, P::Block, RA> as ProvideRuntimeApi<P::Block>>::Api:
+		SessionKeys<P::Block, Error = ClientError>,
 {
 	type Metadata = crate::metadata::Metadata;
 

substrate/client/rpc/src/chain/chain_full.rs

@@ -22,11 +22,7 @@ use rpc::futures::future::result;
 use sc_rpc_api::Subscriptions;
 use sc_client_api::{CallExecutor, backend::Backend};
 use sc_client::Client;
-use sp_core::{H256, Blake2Hasher};
-use sp_runtime::{
-	generic::{BlockId, SignedBlock},
-	traits::{Block as BlockT},
-};
+use sp_runtime::{generic::{BlockId, SignedBlock}, traits::{Block as BlockT}};
 
 use super::{ChainBackend, client_err, error::FutureResult};
 
@@ -49,9 +45,9 @@ impl<B, E, Block: BlockT, RA> FullChain<B, E, Block, RA> {
 }
 
 impl<B, E, Block, RA> ChainBackend<B, E, Block, RA> for FullChain<B, E, Block, RA> where
-	Block: BlockT<Hash=H256> + 'static,
-	B: Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-	E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static,
+	Block: BlockT + 'static,
+	B: Backend<Block> + Send + Sync + 'static,
+	E: CallExecutor<Block> + Send + Sync + 'static,
 	RA: Send + Sync + 'static,
 {
 	fn client(&self) -> &Arc<Client<B, E, Block, RA>> {

substrate/client/rpc/src/chain/chain_light.rs

@@ -22,13 +22,8 @@ use rpc::futures::future::{result, Future, Either};
 
 use sc_rpc_api::Subscriptions;
 use sc_client::{
-	self, Client,
-	light::{
-		fetcher::{Fetcher, RemoteBodyRequest},
-		blockchain::RemoteBlockchain,
-	},
+	Client, light::{fetcher::{Fetcher, RemoteBodyRequest}, blockchain::RemoteBlockchain},
 };
-use sp_core::{H256, Blake2Hasher};
 use sp_runtime::{
 	generic::{BlockId, SignedBlock},
 	traits::{Block as BlockT},
@@ -67,9 +62,9 @@ impl<B, E, Block: BlockT, RA, F: Fetcher<Block>> LightChain<B, E, Block, RA, F>
 }
 
 impl<B, E, Block, RA, F> ChainBackend<B, E, Block, RA> for LightChain<B, E, Block, RA, F> where
-	Block: BlockT<Hash=H256> + 'static,
-	B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-	E: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static,
+	Block: BlockT + 'static,
+	B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+	E: sc_client::CallExecutor<Block> + Send + Sync + 'static,
 	RA: Send + Sync + 'static,
 	F: Fetcher<Block> + Send + Sync + 'static,
 {

substrate/client/rpc/src/chain/mod.rs

@@ -36,7 +36,6 @@ use sc_client::{
 	light::{fetcher::Fetcher, blockchain::RemoteBlockchain},
 };
 use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
-use sp_core::{H256, Blake2Hasher};
 use sp_rpc::{number::NumberOrHex, list::ListOrValue};
 use sp_runtime::{
 	generic::{BlockId, SignedBlock},
@@ -50,9 +49,9 @@ pub use sc_rpc_api::chain::*;
 /// Blockchain backend API
 trait ChainBackend<B, E, Block: BlockT, RA>: Send + Sync + 'static
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static,
+		Block: BlockT + 'static,
+		B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		E: sc_client::CallExecutor<Block> + Send + Sync + 'static,
 {
 	/// Get client reference.
 	fn client(&self) -> &Arc<Client<B, E, Block, RA>>;
@@ -155,9 +154,9 @@ pub fn new_full<B, E, Block: BlockT, RA>(
 	subscriptions: Subscriptions,
 ) -> Chain<B, E, Block, RA>
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT + 'static,
+		B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		E: sc_client::CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
 {
 	Chain {
@@ -173,9 +172,9 @@ pub fn new_light<B, E, Block: BlockT, RA, F: Fetcher<Block>>(
 	fetcher: Arc<F>,
 ) -> Chain<B, E, Block, RA>
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT + 'static,
+		B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		E: sc_client::CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
 		F: Send + Sync + 'static,
 {
@@ -195,9 +194,9 @@ pub struct Chain<B, E, Block: BlockT, RA> {
 }
 
 impl<B, E, Block, RA> ChainApi<NumberFor<Block>, Block::Hash, Block::Header, SignedBlock<Block>> for Chain<B, E, Block, RA> where
-	Block: BlockT<Hash=H256> + 'static,
-	B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-	E: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static,
+	Block: BlockT + 'static,
+	B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+	E: sc_client::CallExecutor<Block> + Send + Sync + 'static,
 	RA: Send + Sync + 'static
 {
 	type Metadata = crate::metadata::Metadata;
@@ -255,9 +254,9 @@ fn subscribe_headers<B, E, Block, RA, F, G, S, ERR>(
 	best_block_hash: G,
 	stream: F,
 ) where
-	Block: BlockT<Hash=H256> + 'static,
-	B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-	E: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static,
+	Block: BlockT + 'static,
+	B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+	E: sc_client::CallExecutor<Block> + Send + Sync + 'static,
 	F: FnOnce() -> S,
 	G: FnOnce() -> Block::Hash,
 	ERR: ::std::fmt::Debug,

substrate/client/rpc/src/chain/tests.rs

@@ -25,7 +25,7 @@ use sp_rpc::list::ListOrValue;
 
 #[test]
 fn should_return_header() {
-	let core = ::tokio::runtime::Runtime::new().unwrap();
+	let core = tokio::runtime::Runtime::new().unwrap();
 	let remote = core.executor();
 
 	let client = Arc::new(substrate_test_runtime_client::new());
@@ -37,7 +37,8 @@ fn should_return_header() {
 			parent_hash: H256::from_low_u64_be(0),
 			number: 0,
 			state_root: x.state_root.clone(),
-			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
+			extrinsics_root:
+				"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
 			digest: Default::default(),
 		}
 	);
@@ -48,26 +49,24 @@ fn should_return_header() {
 			parent_hash: H256::from_low_u64_be(0),
 			number: 0,
 			state_root: x.state_root.clone(),
-			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
+			extrinsics_root:
+				"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
 			digest: Default::default(),
 		}
 	);
 
-	assert_matches!(
-		api.header(Some(H256::from_low_u64_be(5)).into()).wait(),
-		Ok(None)
-	);
+	assert_matches!(api.header(Some(H256::from_low_u64_be(5)).into()).wait(), Ok(None));
 }
 
 #[test]
 fn should_return_a_block() {
-	let core = ::tokio::runtime::Runtime::new().unwrap();
+	let core = tokio::runtime::Runtime::new().unwrap();
 	let remote = core.executor();
 
-	let client = Arc::new(substrate_test_runtime_client::new());
+	let mut client = Arc::new(substrate_test_runtime_client::new());
 	let api = new_full(client.clone(), Subscriptions::new(Arc::new(remote)));
 
-	let block = client.new_block(Default::default()).unwrap().bake().unwrap();
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
 	let block_hash = block.hash();
 	client.import(BlockOrigin::Own, block).unwrap();
 
@@ -84,7 +83,8 @@ fn should_return_a_block() {
 				parent_hash: client.genesis_hash(),
 				number: 1,
 				state_root: x.block.header.state_root.clone(),
-				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
+				extrinsics_root:
+					"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
 				digest: Default::default(),
 			},
 			extrinsics: vec![],
@@ -98,7 +98,8 @@ fn should_return_a_block() {
 				parent_hash: client.genesis_hash(),
 				number: 1,
 				state_root: x.block.header.state_root.clone(),
-				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
+				extrinsics_root:
+					"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
 				digest: Default::default(),
 			},
 			extrinsics: vec![],
@@ -116,7 +117,7 @@ fn should_return_block_hash() {
 	let core = ::tokio::runtime::Runtime::new().unwrap();
 	let remote = core.executor();
 
-	let client = Arc::new(substrate_test_runtime_client::new());
+	let mut client = Arc::new(substrate_test_runtime_client::new());
 	let api = new_full(client.clone(), Subscriptions::new(Arc::new(remote)));
 
 	assert_matches!(
@@ -135,7 +136,7 @@ fn should_return_block_hash() {
 		Ok(ListOrValue::Value(None))
 	);
 
-	let block = client.new_block(Default::default()).unwrap().bake().unwrap();
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
 	client.import(BlockOrigin::Own, block.clone()).unwrap();
 
 	assert_matches!(
@@ -163,7 +164,7 @@ fn should_return_finalized_hash() {
 	let core = ::tokio::runtime::Runtime::new().unwrap();
 	let remote = core.executor();
 
-	let client = Arc::new(substrate_test_runtime_client::new());
+	let mut client = Arc::new(substrate_test_runtime_client::new());
 	let api = new_full(client.clone(), Subscriptions::new(Arc::new(remote)));
 
 	assert_matches!(
@@ -172,8 +173,8 @@ fn should_return_finalized_hash() {
 	);
 
 	// import new block
-	let builder = client.new_block(Default::default()).unwrap();
-	client.import(BlockOrigin::Own, builder.bake().unwrap()).unwrap();
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block).unwrap();
 	// no finalization yet
 	assert_matches!(
 		api.finalized_head(),
@@ -195,7 +196,7 @@ fn should_notify_about_latest_block() {
 	let (subscriber, id, transport) = Subscriber::new_test("test");
 
 	{
-		let client = Arc::new(substrate_test_runtime_client::new());
+		let mut client = Arc::new(substrate_test_runtime_client::new());
 		let api = new_full(client.clone(), Subscriptions::new(Arc::new(remote)));
 
 		api.subscribe_new_heads(Default::default(), subscriber);
@@ -203,8 +204,8 @@ fn should_notify_about_latest_block() {
 		// assert id assigned
 		assert_eq!(core.block_on(id), Ok(Ok(SubscriptionId::Number(1))));
 
-		let builder = client.new_block(Default::default()).unwrap();
-		client.import(BlockOrigin::Own, builder.bake().unwrap()).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		client.import(BlockOrigin::Own, block).unwrap();
 	}
 
 	// assert initial head sent.
@@ -224,7 +225,7 @@ fn should_notify_about_finalized_block() {
 	let (subscriber, id, transport) = Subscriber::new_test("test");
 
 	{
-		let client = Arc::new(substrate_test_runtime_client::new());
+		let mut client = Arc::new(substrate_test_runtime_client::new());
 		let api = new_full(client.clone(), Subscriptions::new(Arc::new(remote)));
 
 		api.subscribe_finalized_heads(Default::default(), subscriber);
@@ -232,8 +233,8 @@ fn should_notify_about_finalized_block() {
 		// assert id assigned
 		assert_eq!(core.block_on(id), Ok(Ok(SubscriptionId::Number(1))));
 
-		let builder = client.new_block(Default::default()).unwrap();
-		client.import(BlockOrigin::Own, builder.bake().unwrap()).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		client.import(BlockOrigin::Own, block).unwrap();
 		client.finalize_block(BlockId::number(1), None).unwrap();
 	}
 

substrate/client/rpc/src/state/mod.rs

@@ -28,16 +28,11 @@ use rpc::{Result as RpcResult, futures::Future};
 
 use sc_rpc_api::Subscriptions;
 use sc_client::{Client, CallExecutor, light::{blockchain::RemoteBlockchain, fetcher::Fetcher}};
-use sp_core::{
-	Blake2Hasher, Bytes, H256,
-	storage::{StorageKey, StorageData, StorageChangeSet},
-};
+use sp_core::{Bytes, storage::{StorageKey, StorageData, StorageChangeSet}};
 use sp_version::RuntimeVersion;
-use sp_runtime::{
-	traits::{Block as BlockT, ProvideRuntimeApi},
-};
+use sp_runtime::traits::Block as BlockT;
 
-use sp_api::Metadata;
+use sp_api::{Metadata, ProvideRuntimeApi};
 
 use self::error::{Error, FutureResult};
 
@@ -46,9 +41,9 @@ pub use sc_rpc_api::state::*;
 /// State backend API.
 pub trait StateBackend<B, E, Block: BlockT, RA>: Send + Sync + 'static
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static,
+		Block: BlockT + 'static,
+		B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		E: sc_client::CallExecutor<Block> + Send + Sync + 'static,
 		RA: Send + Sync + 'static,
 {
 	/// Call runtime method at given block.
@@ -186,12 +181,12 @@ pub fn new_full<B, E, Block: BlockT, RA>(
 	subscriptions: Subscriptions,
 ) -> State<B, E, Block, RA>
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT + 'static,
+		B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		E: CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
-		Client<B, E, Block, RA>: ProvideRuntimeApi,
-		<Client<B, E, Block, RA> as ProvideRuntimeApi>::Api:
+		Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
+		<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api:
 			Metadata<Block, Error = sp_blockchain::Error>,
 {
 	State {
@@ -207,9 +202,9 @@ pub fn new_light<B, E, Block: BlockT, RA, F: Fetcher<Block>>(
 	fetcher: Arc<F>,
 ) -> State<B, E, Block, RA>
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT + 'static,
+		B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		E: CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
 		F: Send + Sync + 'static,
 {
@@ -230,9 +225,9 @@ pub struct State<B, E, Block, RA> {
 
 impl<B, E, Block, RA> StateApi<Block::Hash> for State<B, E, Block, RA>
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT + 'static,
+		B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		E: CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
 {
 	type Metadata = crate::metadata::Metadata;

substrate/client/rpc/src/state/state_full.rs

@@ -22,10 +22,7 @@ use std::ops::Range;
 use futures::{future, StreamExt as _, TryStreamExt as _};
 use log::warn;
 use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
-use rpc::{
-	Result as RpcResult,
-	futures::{stream, Future, Sink, Stream, future::result},
-};
+use rpc::{Result as RpcResult, futures::{stream, Future, Sink, Stream, future::result}};
 
 use sc_rpc_api::Subscriptions;
 use sc_client_api::backend::Backend;
@@ -36,17 +33,15 @@ use sc_client::{
 	Client, CallExecutor, BlockchainEvents,
 };
 use sp_core::{
-	H256, Blake2Hasher, Bytes,
-	storage::{well_known_keys, StorageKey, StorageData, StorageChangeSet, ChildInfo},
+	Bytes, storage::{well_known_keys, StorageKey, StorageData, StorageChangeSet, ChildInfo},
 };
 use sp_version::RuntimeVersion;
 use sp_state_machine::ExecutionStrategy;
 use sp_runtime::{
-	generic::BlockId,
-	traits::{Block as BlockT, NumberFor, ProvideRuntimeApi, SaturatedConversion},
+	generic::BlockId, traits::{Block as BlockT, NumberFor, SaturatedConversion},
 };
 
-use sp_api::Metadata;
+use sp_api::{Metadata, ProvideRuntimeApi};
 
 use super::{StateBackend, error::{FutureResult, Error, Result}, client_err, child_resolution_error};
 
@@ -72,9 +67,9 @@ pub struct FullState<B, E, Block: BlockT, RA> {
 
 impl<B, E, Block: BlockT, RA> FullState<B, E, Block, RA>
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT + 'static,
+		B: Backend<Block> + Send + Sync + 'static,
+		E: CallExecutor<Block> + Send + Sync + 'static + Clone,
 {
 	/// Create new state API backend for full nodes.
 	pub fn new(client: Arc<Client<B, E, Block, RA>>, subscriptions: Subscriptions) -> Self {
@@ -220,12 +215,12 @@ impl<B, E, Block: BlockT, RA> FullState<B, E, Block, RA>
 
 impl<B, E, Block, RA> StateBackend<B, E, Block, RA> for FullState<B, E, Block, RA>
 	where
-		Block: BlockT<Hash=H256> + 'static,
-		B: Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT + 'static,
+		B: Backend<Block> + Send + Sync + 'static,
+		E: CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
-		Client<B, E, Block, RA>: ProvideRuntimeApi,
-		<Client<B, E, Block, RA> as ProvideRuntimeApi>::Api:
+		Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
+		<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api:
 			Metadata<Block, Error = sp_blockchain::Error>,
 {
 	fn call(

substrate/client/rpc/src/state/state_light.rs

@@ -49,14 +49,10 @@ use sc_client::{
 	},
 };
 use sp_core::{
-	H256, Blake2Hasher, Bytes, OpaqueMetadata,
-	storage::{StorageKey, StorageData, StorageChangeSet},
+	Bytes, OpaqueMetadata, storage::{StorageKey, StorageData, StorageChangeSet},
 };
 use sp_version::RuntimeVersion;
-use sp_runtime::{
-	generic::BlockId,
-	traits::Block as BlockT,
-};
+use sp_runtime::{generic::BlockId, traits::{Block as BlockT, HasherFor}};
 
 use super::{StateBackend, error::{FutureResult, Error}, client_err};
 
@@ -140,9 +136,9 @@ impl<Hash, V> SharedRequests<Hash, V> for SimpleSubscriptions<Hash, V> where
 
 impl<Block: BlockT, F: Fetcher<Block> + 'static, B, E, RA> LightState<Block, F, B, E, RA>
 	where
-		Block: BlockT<Hash=H256>,
-		B: Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT,
+		B: Backend<Block> + Send + Sync + 'static,
+		E: CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
 {
 	/// Create new state API backend for light nodes.
@@ -174,9 +170,9 @@ impl<Block: BlockT, F: Fetcher<Block> + 'static, B, E, RA> LightState<Block, F,
 
 impl<Block, F, B, E, RA> StateBackend<B, E, Block, RA> for LightState<Block, F, B, E, RA>
 	where
-		Block: BlockT<Hash=H256>,
-		B: Backend<Block, Blake2Hasher> + Send + Sync + 'static,
-		E: CallExecutor<Block, Blake2Hasher> + Send + Sync + 'static + Clone,
+		Block: BlockT,
+		B: Backend<Block> + Send + Sync + 'static,
+		E: CallExecutor<Block> + Send + Sync + 'static + Clone,
 		RA: Send + Sync + 'static,
 		F: Fetcher<Block> + 'static
 {
@@ -227,7 +223,7 @@ impl<Block, F, B, E, RA> StateBackend<B, E, Block, RA> for LightState<Block, F,
 		Box::new(self
 			.storage(block, key)
 			.and_then(|maybe_storage|
-				result(Ok(maybe_storage.map(|storage| Blake2Hasher::hash(&storage.0))))
+				result(Ok(maybe_storage.map(|storage| HasherFor::<Block>::hash(&storage.0))))
 			)
 		)
 	}
@@ -288,7 +284,7 @@ impl<Block, F, B, E, RA> StateBackend<B, E, Block, RA> for LightState<Block, F,
 		Box::new(self
 			.child_storage(block, child_storage_key, child_info, child_type, key)
 			.and_then(|maybe_storage|
-				result(Ok(maybe_storage.map(|storage| Blake2Hasher::hash(&storage.0))))
+				result(Ok(maybe_storage.map(|storage| HasherFor::<Block>::hash(&storage.0))))
 			)
 		)
 	}
@@ -602,7 +598,7 @@ fn subscription_stream<
 	issue_request: IssueRequest,
 	compare_values: CompareValues,
 ) -> impl Stream<Item=N, Error=()> where
-	Block: BlockT<Hash=H256>,
+	Block: BlockT,
 	Requests: 'static + SharedRequests<Block::Hash, V>,
 	FutureBlocksStream: Stream<Item=Block::Hash, Error=()>,
 	V: Send + 'static + Clone,
@@ -712,6 +708,7 @@ fn ignore_error<F, T>(future: F) -> impl std::future::Future<Output=Result<Optio
 mod tests {
 	use rpc::futures::stream::futures_ordered;
 	use substrate_test_runtime_client::runtime::Block;
+    use sp_core::H256;
 	use super::*;
 
 	#[test]

substrate/client/rpc/src/state/tests.rs

@@ -143,7 +143,7 @@ fn should_notify_about_storage_changes() {
 	let (subscriber, id, transport) = Subscriber::new_test("test");
 
 	{
-		let client = Arc::new(substrate_test_runtime_client::new());
+		let mut client = Arc::new(substrate_test_runtime_client::new());
 		let api = new_full(client.clone(), Subscriptions::new(Arc::new(remote)));
 
 		api.subscribe_storage(Default::default(), subscriber, None.into());
@@ -158,7 +158,8 @@ fn should_notify_about_storage_changes() {
 			amount: 42,
 			nonce: 0,
 		}).unwrap();
-		client.import(BlockOrigin::Own, builder.bake().unwrap()).unwrap();
+		let block = builder.build().unwrap().block;
+		client.import(BlockOrigin::Own, block).unwrap();
 	}
 
 	// assert notification sent to transport
@@ -175,7 +176,7 @@ fn should_send_initial_storage_changes_and_notifications() {
 	let (subscriber, id, transport) = Subscriber::new_test("test");
 
 	{
-		let client = Arc::new(substrate_test_runtime_client::new());
+		let mut client = Arc::new(substrate_test_runtime_client::new());
 		let api = new_full(client.clone(), Subscriptions::new(Arc::new(remote)));
 
 		let alice_balance_key = blake2_256(&runtime::system::balance_of_key(AccountKeyring::Alice.into()));
@@ -194,7 +195,8 @@ fn should_send_initial_storage_changes_and_notifications() {
 			amount: 42,
 			nonce: 0,
 		}).unwrap();
-		client.import(BlockOrigin::Own, builder.bake().unwrap()).unwrap();
+		let block = builder.build().unwrap().block;
+		client.import(BlockOrigin::Own, block).unwrap();
 	}
 
 	// assert initial values sent to transport
@@ -209,11 +211,11 @@ fn should_send_initial_storage_changes_and_notifications() {
 
 #[test]
 fn should_query_storage() {
-	fn run_tests(client: Arc<TestClient>) {
+	fn run_tests(mut client: Arc<TestClient>) {
 		let core = tokio::runtime::Runtime::new().unwrap();
 		let api = new_full(client.clone(), Subscriptions::new(Arc::new(core.executor())));
 
-		let add_block = |nonce| {
+		let mut add_block = |nonce| {
 			let mut builder = client.new_block(Default::default()).unwrap();
 			// fake change: None -> None -> None
 			builder.push_storage_change(vec![1], None).unwrap();
@@ -225,7 +227,7 @@ fn should_query_storage() {
 			builder.push_storage_change(vec![4], if nonce == 0 { None } else { Some(vec![4]) }).unwrap();
 			// actual change: Some(value1) -> Some(value2)
 			builder.push_storage_change(vec![5], Some(vec![nonce as u8])).unwrap();
-			let block = builder.bake().unwrap();
+			let block = builder.build().unwrap().block;
 			let hash = block.header.hash();
 			client.import(BlockOrigin::Own, block).unwrap();
 			hash