Make BlockImport and Verifier async (#8472)

* Make grandpa work

* Introduce `SharedData`

* Add test and fix bugs

* Switch to `SharedData`

* Make grandpa tests working

* More Babe work

* Make it async

* Fix fix

* Use `async_trait` in sc-consensus-slots

This makes the code a little bit easier to read and also expresses that
there can always only be one call at a time to `on_slot`.

* Make grandpa tests compile

* More Babe tests work

* Fix network test

* Start fixing service test

* Finish service-test

* Fix sc-consensus-aura

* Fix fix fix

* More fixes

* Make everything compile *yeah*

* Fix build when we have Rust 1.51

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/babe/src/tests.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/babe/src/tests.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Fix warning

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

substrate/client/service/test/src/client/light.rs

@@ -375,11 +375,11 @@ fn execution_proof_is_generated_and_checked() {
 	for i in 1u32..3u32 {
 		let mut digest = Digest::default();
 		digest.push(sp_runtime::generic::DigestItem::Other::<H256>(i.to_le_bytes().to_vec()));
-		remote_client.import_justified(
+		futures::executor::block_on(remote_client.import_justified(
 			BlockOrigin::Own,
 			remote_client.new_block(digest).unwrap().build().unwrap().block,
 			Justifications::from((*b"TEST", Default::default())),
-		).unwrap();
+		)).unwrap();
 	}
 
 	// check method that doesn't requires environment
@@ -540,7 +540,7 @@ fn prepare_for_header_proof_check(insert_cht: bool) -> (TestChecker, Hash, Heade
 	let mut local_headers_hashes = Vec::new();
 	for i in 0..4 {
 		let block = remote_client.new_block(Default::default()).unwrap().build().unwrap().block;
-		remote_client.import(BlockOrigin::Own, block).unwrap();
+		futures::executor::block_on(remote_client.import(BlockOrigin::Own, block)).unwrap();
 		local_headers_hashes.push(
 			remote_client.block_hash(i + 1)
 				.map_err(|_| ClientError::Backend("TestError".into()))

substrate/client/service/test/src/client/mod.rs

@@ -54,6 +54,7 @@ use sp_storage::StorageKey;
 use sp_trie::{TrieConfiguration, trie_types::Layout};
 use sp_runtime::{generic::BlockId, DigestItem, Justifications};
 use hex_literal::hex;
+use futures::executor::block_on;
 
 mod light;
 mod db;
@@ -108,7 +109,7 @@ pub fn prepare_client_with_key_changes() -> (
 			}).unwrap();
 		}
 		let block = builder.build().unwrap().block;
-		remote_client.import(BlockOrigin::Own, block).unwrap();
+		block_on(remote_client.import(BlockOrigin::Own, block)).unwrap();
 
 		let header = remote_client.header(&BlockId::Number(i as u64 + 1)).unwrap().unwrap();
 		let trie_root = header.digest().log(DigestItem::as_changes_trie_root)
@@ -363,7 +364,7 @@ fn block_builder_works_with_no_transactions() {
 
 	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
 
-	client.import(BlockOrigin::Own, block).unwrap();
+	block_on(client.import(BlockOrigin::Own, block)).unwrap();
 
 	assert_eq!(client.chain_info().best_number, 1);
 }
@@ -382,7 +383,7 @@ fn block_builder_works_with_transactions() {
 	}).unwrap();
 
 	let block = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, block).unwrap();
+	block_on(client.import(BlockOrigin::Own, block)).unwrap();
 
 	assert_eq!(client.chain_info().best_number, 1);
 	assert_ne!(
@@ -428,7 +429,7 @@ fn block_builder_does_not_include_invalid() {
 	);
 
 	let block = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, block).unwrap();
+	block_on(client.import(BlockOrigin::Own, block)).unwrap();
 
 	assert_eq!(client.chain_info().best_number, 1);
 	assert_ne!(
@@ -476,11 +477,11 @@ fn uncles_with_only_ancestors() {
 
 	// G -> A1
 	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	// A1 -> A2
 	let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 	let v: Vec<H256> = Vec::new();
 	assert_eq!(v, client.uncles(a2.hash(), 3).unwrap());
 }
@@ -496,7 +497,7 @@ fn uncles_with_multiple_forks() {
 
 	// G -> A1
 	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	// A1 -> A2
 	let a2 = client.new_block_at(
@@ -504,7 +505,7 @@ fn uncles_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	// A2 -> A3
 	let a3 = client.new_block_at(
@@ -512,7 +513,7 @@ fn uncles_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a3.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
 
 	// A3 -> A4
 	let a4 = client.new_block_at(
@@ -520,7 +521,7 @@ fn uncles_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a4.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
 
 	// A4 -> A5
 	let a5 = client.new_block_at(
@@ -528,7 +529,7 @@ fn uncles_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a5.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
 
 	// A1 -> B2
 	let mut builder = client.new_block_at(
@@ -544,7 +545,7 @@ fn uncles_with_multiple_forks() {
 		nonce: 0,
 	}).unwrap();
 	let b2 = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, b2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
 
 	// B2 -> B3
 	let b3 = client.new_block_at(
@@ -552,7 +553,7 @@ fn uncles_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, b3.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
 
 	// B3 -> B4
 	let b4 = client.new_block_at(
@@ -560,7 +561,7 @@ fn uncles_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, b4.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
 
 	// // B2 -> C3
 	let mut builder = client.new_block_at(
@@ -576,7 +577,7 @@ fn uncles_with_multiple_forks() {
 		nonce: 1,
 	}).unwrap();
 	let c3 = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, c3.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
 
 	// A1 -> D2
 	let mut builder = client.new_block_at(
@@ -592,7 +593,7 @@ fn uncles_with_multiple_forks() {
 		nonce: 0,
 	}).unwrap();
 	let d2 = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, d2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
 
 	let genesis_hash = client.chain_info().genesis_hash;
 
@@ -624,11 +625,11 @@ fn best_containing_on_longest_chain_with_single_chain_3_blocks() {
 
 	// G -> A1
 	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	// A1 -> A2
 	let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	let genesis_hash = client.chain_info().genesis_hash;
 
@@ -648,7 +649,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 
 	// G -> A1
 	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	// A1 -> A2
 	let a2 = client.new_block_at(
@@ -656,7 +657,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	// A2 -> A3
 	let a3 = client.new_block_at(
@@ -664,7 +665,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a3.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
 
 	// A3 -> A4
 	let a4 = client.new_block_at(
@@ -672,7 +673,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a4.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
 
 	// A4 -> A5
 	let a5 = client.new_block_at(
@@ -680,7 +681,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a5.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
 
 	// A1 -> B2
 	let mut builder = client.new_block_at(
@@ -696,7 +697,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		nonce: 0,
 	}).unwrap();
 	let b2 = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, b2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
 
 	// B2 -> B3
 	let b3 = client.new_block_at(
@@ -704,7 +705,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, b3.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
 
 	// B3 -> B4
 	let b4 = client.new_block_at(
@@ -712,7 +713,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, b4.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
 
 	// // B2 -> C3
 	let mut builder = client.new_block_at(
@@ -728,7 +729,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		nonce: 1,
 	}).unwrap();
 	let c3 = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, c3.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
 
 	// A1 -> D2
 	let mut builder = client.new_block_at(
@@ -744,7 +745,7 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		nonce: 0,
 	}).unwrap();
 	let d2 = builder.build().unwrap().block;
-	client.import(BlockOrigin::Own, d2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
 
 	assert_eq!(client.chain_info().best_hash, a5.hash());
 
@@ -952,11 +953,15 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 	assert_eq!(None, longest_chain_select.finality_target(
 		b4.hash(), Some(0)).unwrap());
 
-	assert_eq!(None, longest_chain_select.finality_target(
-		c3.hash().clone(), Some(0)).unwrap());
+	assert_eq!(
+		None,
+		longest_chain_select.finality_target(c3.hash().clone(), Some(0)).unwrap(),
+	);
 
-	assert_eq!(None, longest_chain_select.finality_target(
-		d2.hash().clone(), Some(0)).unwrap());
+	assert_eq!(
+		None,
+		longest_chain_select.finality_target(d2.hash().clone(), Some(0)).unwrap(),
+	);
 }
 
 #[test]
@@ -968,15 +973,18 @@ fn best_containing_on_longest_chain_with_max_depth_higher_than_best() {
 
 	// G -> A1
 	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	// A1 -> A2
 	let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	let genesis_hash = client.chain_info().genesis_hash;
 
-	assert_eq!(a2.hash(), longest_chain_select.finality_target(genesis_hash, Some(10)).unwrap().unwrap());
+	assert_eq!(
+		a2.hash(),
+		longest_chain_select.finality_target(genesis_hash, Some(10)).unwrap().unwrap(),
+	);
 }
 
 #[test]
@@ -1008,7 +1016,7 @@ fn import_with_justification() {
 
 	// G -> A1
 	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	// A1 -> A2
 	let a2 = client.new_block_at(
@@ -1016,7 +1024,7 @@ fn import_with_justification() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	// A2 -> A3
 	let justification = Justifications::from((TEST_ENGINE_ID, vec![1, 2, 3]));
@@ -1025,7 +1033,7 @@ fn import_with_justification() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import_justified(BlockOrigin::Own, a3.clone(), justification.clone()).unwrap();
+	block_on(client.import_justified(BlockOrigin::Own, a3.clone(), justification.clone())).unwrap();
 
 	assert_eq!(
 		client.chain_info().finalized_hash,
@@ -1060,14 +1068,14 @@ fn importing_diverged_finalized_block_should_trigger_reorg() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	let a2 = client.new_block_at(
 		&BlockId::Hash(a1.hash()),
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	let mut b1 = client.new_block_at(
 		&BlockId::Number(0),
@@ -1092,7 +1100,7 @@ fn importing_diverged_finalized_block_should_trigger_reorg() {
 
 	// importing B1 as finalized should trigger a re-org and set it as new best
 	let justification = Justifications::from((TEST_ENGINE_ID, vec![1, 2, 3]));
-	client.import_justified(BlockOrigin::Own, b1.clone(), justification).unwrap();
+	block_on(client.import_justified(BlockOrigin::Own, b1.clone(), justification)).unwrap();
 
 	assert_eq!(
 		client.chain_info().best_hash,
@@ -1117,14 +1125,14 @@ fn finalizing_diverged_block_should_trigger_reorg() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	let a2 = client.new_block_at(
 		&BlockId::Hash(a1.hash()),
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	let mut b1 = client.new_block_at(
 		&BlockId::Number(0),
@@ -1139,14 +1147,14 @@ fn finalizing_diverged_block_should_trigger_reorg() {
 		nonce: 0,
 	}).unwrap();
 	let b1 = b1.build().unwrap().block;
-	client.import(BlockOrigin::Own, b1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b1.clone())).unwrap();
 
 	let b2 = client.new_block_at(
 		&BlockId::Hash(b1.hash()),
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, b2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
 
 	// A2 is the current best since it's the longest chain
 	assert_eq!(
@@ -1184,7 +1192,7 @@ fn finalizing_diverged_block_should_trigger_reorg() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, b3.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
 
 	assert_eq!(
 		client.chain_info().best_hash,
@@ -1227,7 +1235,7 @@ fn state_reverted_on_reorg() {
 		nonce: 0,
 	}).unwrap();
 	let a1 = a1.build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	let mut b1 = client.new_block_at(
 		&BlockId::Number(0),
@@ -1242,7 +1250,7 @@ fn state_reverted_on_reorg() {
 	}).unwrap();
 	let b1 = b1.build().unwrap().block;
 	// Reorg to B1
-	client.import_as_best(BlockOrigin::Own, b1.clone()).unwrap();
+	block_on(client.import_as_best(BlockOrigin::Own, b1.clone())).unwrap();
 
 	assert_eq!(950, current_balance(&client));
 	let mut a2 = client.new_block_at(
@@ -1258,7 +1266,7 @@ fn state_reverted_on_reorg() {
 	}).unwrap();
 	let a2 = a2.build().unwrap().block;
 	// Re-org to A2
-	client.import_as_best(BlockOrigin::Own, a2).unwrap();
+	block_on(client.import_as_best(BlockOrigin::Own, a2)).unwrap();
 	assert_eq!(980, current_balance(&client));
 }
 
@@ -1297,14 +1305,14 @@ fn doesnt_import_blocks_that_revert_finality() {
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
 
 	let a2 = client.new_block_at(
 		&BlockId::Hash(a1.hash()),
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
 
 	let mut b1 = client.new_block_at(&BlockId::Number(0), Default::default(), false).unwrap();
 
@@ -1316,11 +1324,11 @@ fn doesnt_import_blocks_that_revert_finality() {
 		nonce: 0,
 	}).unwrap();
 	let b1 = b1.build().unwrap().block;
-	client.import(BlockOrigin::Own, b1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b1.clone())).unwrap();
 
 	let b2 = client.new_block_at(&BlockId::Hash(b1.hash()), Default::default(), false)
 		.unwrap().build().unwrap().block;
-	client.import(BlockOrigin::Own, b2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
 
 	// prepare B3 before we finalize A2, because otherwise we won't be able to
 	// read changes trie configuration after A2 is finalized
@@ -1331,7 +1339,7 @@ fn doesnt_import_blocks_that_revert_finality() {
 	// B3 at the same height but that doesn't include it
 	ClientExt::finalize_block(&client, BlockId::Hash(a2.hash()), None).unwrap();
 
-	let import_err = client.import(BlockOrigin::Own, b3).err().unwrap();
+	let import_err = block_on(client.import(BlockOrigin::Own, b3)).err().unwrap();
 	let expected_err = ConsensusError::ClientImport(
 		sp_blockchain::Error::RuntimeApiError(
 			sp_api::ApiError::Application(Box::new(sp_blockchain::Error::NotInFinalizedChain))
@@ -1356,7 +1364,7 @@ fn doesnt_import_blocks_that_revert_finality() {
 	}).unwrap();
 	let c1 = c1.build().unwrap().block;
 
-	let import_err = client.import(BlockOrigin::Own, c1).err().unwrap();
+	let import_err = block_on(client.import(BlockOrigin::Own, c1)).err().unwrap();
 	let expected_err = ConsensusError::ClientImport(
 		sp_blockchain::Error::NotInFinalizedChain.to_string()
 	);
@@ -1367,7 +1375,6 @@ fn doesnt_import_blocks_that_revert_finality() {
 	);
 }
 
-
 #[test]
 fn respects_block_rules() {
 	fn run_test(
@@ -1396,7 +1403,7 @@ fn respects_block_rules() {
 			allow_missing_state: false,
 			import_existing: false,
 		};
-		assert_eq!(client.check_block(params).unwrap(), ImportResult::imported(false));
+		assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::imported(false));
 
 		// this is 0x0d6d6612a10485370d9e085aeea7ec427fb3f34d961c6a816cdbe5cde2278864
 		let mut block_not_ok = client.new_block_at(&BlockId::Number(0), Default::default(), false)
@@ -1414,11 +1421,11 @@ fn respects_block_rules() {
 		if record_only {
 			known_bad.insert(block_not_ok.hash());
 		} else {
-			assert_eq!(client.check_block(params).unwrap(), ImportResult::KnownBad);
+			assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::KnownBad);
 		}
 
 		// Now going to the fork
-		client.import_as_final(BlockOrigin::Own, block_ok).unwrap();
+		block_on(client.import_as_final(BlockOrigin::Own, block_ok)).unwrap();
 
 		// And check good fork
 		let mut block_ok = client.new_block_at(&BlockId::Number(1), Default::default(), false)
@@ -1436,7 +1443,7 @@ fn respects_block_rules() {
 		if record_only {
 			fork_rules.push((1, block_ok.hash().clone()));
 		}
-		assert_eq!(client.check_block(params).unwrap(), ImportResult::imported(false));
+		assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::imported(false));
 
 		// And now try bad fork
 		let mut block_not_ok = client.new_block_at(&BlockId::Number(1), Default::default(), false)
@@ -1453,7 +1460,7 @@ fn respects_block_rules() {
 		};
 
 		if !record_only {
-			assert_eq!(client.check_block(params).unwrap(), ImportResult::KnownBad);
+			assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::KnownBad);
 		}
 	}
 
@@ -1491,8 +1498,11 @@ fn returns_status_for_pruned_blocks() {
 
 	let mut client = TestClientBuilder::with_backend(backend).build();
 
-	let a1 = client.new_block_at(&BlockId::Number(0), Default::default(), false)
-		.unwrap().build().unwrap().block;
+	let a1 = client.new_block_at(
+		&BlockId::Number(0),
+		Default::default(),
+		false,
+	).unwrap().build().unwrap().block;
 
 	let mut b1 = client.new_block_at(&BlockId::Number(0), Default::default(), false).unwrap();
 
@@ -1513,17 +1523,32 @@ fn returns_status_for_pruned_blocks() {
 		import_existing: false,
 	};
 
-	assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::imported(false));
-	assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::Unknown);
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::imported(false),
+	);
+	assert_eq!(
+		client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
+		BlockStatus::Unknown,
+	);
 
-	client.import_as_final(BlockOrigin::Own, a1.clone()).unwrap();
+	block_on(client.import_as_final(BlockOrigin::Own, a1.clone())).unwrap();
 
-	assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::AlreadyInChain);
-	assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::InChainWithState);
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(
+		client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
+		BlockStatus::InChainWithState,
+	);
 
-	let a2 = client.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
-		.unwrap().build().unwrap().block;
-	client.import_as_final(BlockOrigin::Own, a2.clone()).unwrap();
+	let a2 = client.new_block_at(
+		&BlockId::Hash(a1.hash()),
+		Default::default(),
+		false,
+	).unwrap().build().unwrap().block;
+	block_on(client.import_as_final(BlockOrigin::Own, a2.clone())).unwrap();
 
 	let check_block_a2 = BlockCheckParams {
 		hash: a2.hash().clone(),
@@ -1533,15 +1558,30 @@ fn returns_status_for_pruned_blocks() {
 		import_existing: false,
 	};
 
-	assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::AlreadyInChain);
-	assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::InChainPruned);
-	assert_eq!(client.check_block(check_block_a2.clone()).unwrap(), ImportResult::AlreadyInChain);
-	assert_eq!(client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(), BlockStatus::InChainWithState);
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(
+		client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
+		BlockStatus::InChainPruned,
+	);
+	assert_eq!(
+		block_on(client.check_block(check_block_a2.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(
+		client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(),
+		BlockStatus::InChainWithState,
+	);
 
-	let a3 = client.new_block_at(&BlockId::Hash(a2.hash()), Default::default(), false)
-		.unwrap().build().unwrap().block;
+	let a3 = client.new_block_at(
+		&BlockId::Hash(a2.hash()),
+		Default::default(),
+		false,
+	).unwrap().build().unwrap().block;
 
-	client.import_as_final(BlockOrigin::Own, a3.clone()).unwrap();
+	block_on(client.import_as_final(BlockOrigin::Own, a3.clone())).unwrap();
 	let check_block_a3 = BlockCheckParams {
 		hash: a3.hash().clone(),
 		number: 2,
@@ -1551,12 +1591,30 @@ fn returns_status_for_pruned_blocks() {
 	};
 
 	// a1 and a2 are both pruned at this point
-	assert_eq!(client.check_block(check_block_a1.clone()).unwrap(), ImportResult::AlreadyInChain);
-	assert_eq!(client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(), BlockStatus::InChainPruned);
-	assert_eq!(client.check_block(check_block_a2.clone()).unwrap(), ImportResult::AlreadyInChain);
-	assert_eq!(client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(), BlockStatus::InChainPruned);
-	assert_eq!(client.check_block(check_block_a3.clone()).unwrap(), ImportResult::AlreadyInChain);
-	assert_eq!(client.block_status(&BlockId::hash(check_block_a3.hash)).unwrap(), BlockStatus::InChainWithState);
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(
+		client.block_status(&BlockId::hash(check_block_a1.hash)).unwrap(),
+		BlockStatus::InChainPruned,
+	);
+	assert_eq!(
+		block_on(client.check_block(check_block_a2.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(
+		client.block_status(&BlockId::hash(check_block_a2.hash)).unwrap(),
+		BlockStatus::InChainPruned,
+	);
+	assert_eq!(
+		block_on(client.check_block(check_block_a3.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(
+		client.block_status(&BlockId::hash(check_block_a3.hash)).unwrap(),
+		BlockStatus::InChainWithState,
+	);
 
 	let mut check_block_b1 = BlockCheckParams {
 		hash: b1.hash().clone(),
@@ -1565,11 +1623,20 @@ fn returns_status_for_pruned_blocks() {
 		allow_missing_state: false,
 		import_existing: false,
 	};
-	assert_eq!(client.check_block(check_block_b1.clone()).unwrap(), ImportResult::MissingState);
+	assert_eq!(
+		block_on(client.check_block(check_block_b1.clone())).unwrap(),
+		ImportResult::MissingState,
+	);
 	check_block_b1.allow_missing_state = true;
-	assert_eq!(client.check_block(check_block_b1.clone()).unwrap(), ImportResult::imported(false));
+	assert_eq!(
+		block_on(client.check_block(check_block_b1.clone())).unwrap(),
+		ImportResult::imported(false),
+	);
 	check_block_b1.parent_hash = H256::random();
-	assert_eq!(client.check_block(check_block_b1.clone()).unwrap(), ImportResult::UnknownParent);
+	assert_eq!(
+		block_on(client.check_block(check_block_b1.clone())).unwrap(),
+		ImportResult::UnknownParent,
+	);
 }
 
 #[test]
@@ -1600,18 +1667,18 @@ fn imports_blocks_with_changes_tries_config_change() {
 	(1..11).for_each(|number| {
 		let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
 			.unwrap().build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(11..12).for_each(|number| {
 		let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
 		block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
 		let block = block.build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(12..23).for_each(|number| {
 		let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
 			.unwrap().build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(23..24).for_each(|number| {
 		let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
@@ -1620,24 +1687,24 @@ fn imports_blocks_with_changes_tries_config_change() {
 			digest_levels: 1,
 		})).unwrap();
 		let block = block.build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(24..26).for_each(|number| {
 		let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
 		block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
 		let block = block.build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(26..27).for_each(|number| {
 		let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
 			.unwrap().build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(27..28).for_each(|number| {
 		let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
 		block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
 		let block = block.build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(28..29).for_each(|number| {
 		let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
@@ -1646,23 +1713,23 @@ fn imports_blocks_with_changes_tries_config_change() {
 			digest_levels: 1,
 		})).unwrap();
 		let block = block.build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(29..30).for_each(|number| {
 		let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
 			.unwrap().build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(30..31).for_each(|number| {
 		let mut block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false).unwrap();
 		block.push_storage_change(vec![42], Some(number.to_le_bytes().to_vec())).unwrap();
 		let block = block.build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 	(31..32).for_each(|number| {
 		let block = client.new_block_at(&BlockId::Number(number - 1), Default::default(), false)
 			.unwrap().build().unwrap().block;
-		client.import(BlockOrigin::Own, block).unwrap();
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
 	});
 
 	// now check that configuration cache works
@@ -1778,7 +1845,7 @@ fn cleans_up_closed_notification_sinks_on_block_import() {
 		let mut import = BlockImportParams::new(origin, header);
 		import.body = Some(extrinsics);
 		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
-		client.import_block(import, Default::default()).unwrap();
+		block_on(client.import_block(import, Default::default())).unwrap();
 	};
 
 	// after importing a block we should still have 4 notification sinks
@@ -1821,14 +1888,14 @@ fn reorg_triggers_a_notification_even_for_sources_that_should_not_trigger_notifi
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::NetworkInitialSync, a1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::NetworkInitialSync, a1.clone())).unwrap();
 
 	let a2 = client.new_block_at(
 		&BlockId::Hash(a1.hash()),
 		Default::default(),
 		false,
 	).unwrap().build().unwrap().block;
-	client.import(BlockOrigin::NetworkInitialSync, a2.clone()).unwrap();
+	block_on(client.import(BlockOrigin::NetworkInitialSync, a2.clone())).unwrap();
 
 	let mut b1 = client.new_block_at(
 		&BlockId::Number(0),
@@ -1843,7 +1910,7 @@ fn reorg_triggers_a_notification_even_for_sources_that_should_not_trigger_notifi
 		nonce: 0,
 	}).unwrap();
 	let b1 = b1.build().unwrap().block;
-	client.import(BlockOrigin::NetworkInitialSync, b1.clone()).unwrap();
+	block_on(client.import(BlockOrigin::NetworkInitialSync, b1.clone())).unwrap();
 
 	let b2 = client.new_block_at(
 		&BlockId::Hash(b1.hash()),
@@ -1852,7 +1919,7 @@ fn reorg_triggers_a_notification_even_for_sources_that_should_not_trigger_notifi
 	).unwrap().build().unwrap().block;
 
 	// Should trigger a notification because we reorg
-	client.import_as_best(BlockOrigin::NetworkInitialSync, b2.clone()).unwrap();
+	block_on(client.import_as_best(BlockOrigin::NetworkInitialSync, b2.clone())).unwrap();
 
 	// There should be one notification
 	let notification = notification_stream.next().unwrap();