[Companion #13615] Keystore overhaul (#6892)

* Remove not required async calls

* Fixed missing renaming

* make_keystore can be sync

* More fixes

* Trivial nitpicks

* Cherry pick test fix from master

* Fixes after master merge

* update lockfile for {"substrate"}

---------

Co-authored-by: parity-processbot <>

polkadot/node/network/availability-distribution/src/lib.rs

@@ -16,7 +16,7 @@
 
 use futures::{future::Either, FutureExt, StreamExt, TryFutureExt};
 
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 
 use polkadot_node_network_protocol::request_response::{v1, IncomingRequestReceiver};
 use polkadot_node_subsystem::{
@@ -83,11 +83,7 @@ impl<Context> AvailabilityDistributionSubsystem {
 #[overseer::contextbounds(AvailabilityDistribution, prefix = self::overseer)]
 impl AvailabilityDistributionSubsystem {
 	/// Create a new instance of the availability distribution.
-	pub fn new(
-		keystore: SyncCryptoStorePtr,
-		recvs: IncomingRequestReceivers,
-		metrics: Metrics,
-	) -> Self {
+	pub fn new(keystore: KeystorePtr, recvs: IncomingRequestReceivers, metrics: Metrics) -> Self {
 		let runtime = RuntimeInfo::new(Some(keystore));
 		Self { runtime, recvs, metrics }
 	}

polkadot/node/network/availability-distribution/src/tests/mod.rs

@@ -20,7 +20,7 @@ use futures::{executor, future, Future};
 
 use polkadot_node_network_protocol::request_response::{IncomingRequest, ReqProtocolNames};
 use polkadot_primitives::{CoreState, Hash};
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 
 use polkadot_node_subsystem_test_helpers as test_helpers;
 
@@ -34,7 +34,7 @@ use state::{TestHarness, TestState};
 pub(crate) mod mock;
 
 fn test_harness<T: Future<Output = ()>>(
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	test_fx: impl FnOnce(TestHarness) -> T,
 ) {
 	sp_tracing::try_init_simple();

polkadot/node/network/availability-distribution/src/tests/state.rs

@@ -32,7 +32,7 @@ use futures_timer::Delay;
 use sc_network as network;
 use sc_network::{config as netconfig, config::RequestResponseConfig, IfDisconnected};
 use sp_core::{testing::TaskExecutor, traits::SpawnNamed};
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 
 use polkadot_node_network_protocol::{
 	jaeger,
@@ -83,7 +83,7 @@ pub struct TestState {
 	pub session_info: SessionInfo,
 	/// Cores per relay chain block.
 	pub cores: HashMap<Hash, Vec<CoreState>>,
-	pub keystore: SyncCryptoStorePtr,
+	pub keystore: KeystorePtr,
 }
 
 impl Default for TestState {

polkadot/node/network/bitfield-distribution/src/tests.rs

@@ -37,7 +37,7 @@ use sp_application_crypto::AppKey;
 use sp_authority_discovery::AuthorityPair as AuthorityDiscoveryPair;
 use sp_core::Pair as PairT;
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::{testing::KeyStore, SyncCryptoStore, SyncCryptoStorePtr};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystorePtr};
 
 use std::{iter::FromIterator as _, sync::Arc, time::Duration};
 
@@ -92,13 +92,13 @@ fn prewarmed_state(
 fn state_with_view(
 	view: OurView,
 	relay_parent: Hash,
-) -> (ProtocolState, SigningContext, SyncCryptoStorePtr, ValidatorId) {
+) -> (ProtocolState, SigningContext, KeystorePtr, ValidatorId) {
 	let mut state = ProtocolState::default();
 
 	let signing_context = SigningContext { session_index: 1, parent_hash: relay_parent.clone() };
 
-	let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
-	let validator = SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
+	let keystore: KeystorePtr = Arc::new(MemoryKeystore::new());
+	let validator = Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
 		.expect("generating sr25519 key not to fail");
 
 	state.per_relay_parent = view
@@ -139,43 +139,43 @@ fn receive_invalid_signature() {
 	let signing_context = SigningContext { session_index: 1, parent_hash: hash_a.clone() };
 
 	// another validator not part of the validatorset
-	let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
-	let malicious = SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
+	let keystore: KeystorePtr = Arc::new(MemoryKeystore::new());
+	let malicious = Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
 		.expect("Malicious key created");
-	let validator_0 = SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
-		.expect("key created");
-	let validator_1 = SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
-		.expect("key created");
+	let validator_0 =
+		Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, None).expect("key created");
+	let validator_1 =
+		Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, None).expect("key created");
 
 	let payload = AvailabilityBitfield(bitvec![u8, bitvec::order::Lsb0; 1u8; 32]);
-	let invalid_signed = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let invalid_signed = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload.clone(),
 		&signing_context,
 		ValidatorIndex(0),
 		&malicious.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
-	let invalid_signed_2 = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let invalid_signed_2 = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload.clone(),
 		&signing_context,
 		ValidatorIndex(1),
 		&malicious.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
 
-	let valid_signed = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let valid_signed = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload,
 		&signing_context,
 		ValidatorIndex(0),
 		&validator_0.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -263,13 +263,13 @@ fn receive_invalid_validator_index() {
 	state.peer_views.insert(peer_b.clone(), view![hash_a]);
 
 	let payload = AvailabilityBitfield(bitvec![u8, bitvec::order::Lsb0; 1u8; 32]);
-	let signed = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let signed = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload,
 		&signing_context,
 		ValidatorIndex(42),
 		&validator,
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -323,13 +323,13 @@ fn receive_duplicate_messages() {
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![u8, bitvec::order::Lsb0; 1u8; 32]);
-	let signed_bitfield = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let signed_bitfield = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload,
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -436,13 +436,13 @@ fn do_not_relay_message_twice() {
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![u8, bitvec::order::Lsb0; 1u8; 32]);
-	let signed_bitfield = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let signed_bitfield = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload,
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -547,13 +547,13 @@ fn changing_view() {
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![u8, bitvec::order::Lsb0; 1u8; 32]);
-	let signed_bitfield = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let signed_bitfield = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload,
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -708,13 +708,13 @@ fn do_not_send_message_back_to_origin() {
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![u8, bitvec::order::Lsb0; 1u8; 32]);
-	let signed_bitfield = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let signed_bitfield = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload,
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -823,13 +823,13 @@ fn topology_test() {
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![u8, bitvec::order::Lsb0; 1u8; 32]);
-	let signed_bitfield = executor::block_on(Signed::<AvailabilityBitfield>::sign(
+	let signed_bitfield = Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload,
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");

polkadot/node/network/collator-protocol/src/lib.rs

@@ -28,7 +28,7 @@ use futures::{
 	FutureExt, TryFutureExt,
 };
 
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 
 use polkadot_node_network_protocol::{
 	request_response::{v1 as request_v1, IncomingRequestReceiver},
@@ -70,7 +70,7 @@ pub enum ProtocolSide {
 	/// Validators operate on the relay chain.
 	Validator {
 		/// The keystore holding validator keys.
-		keystore: SyncCryptoStorePtr,
+		keystore: KeystorePtr,
 		/// An eviction policy for inactive peers or validators.
 		eviction_policy: CollatorEvictionPolicy,
 		/// Prometheus metrics for validators.

polkadot/node/network/collator-protocol/src/validator_side/mod.rs

@@ -30,7 +30,7 @@ use std::{
 	time::{Duration, Instant},
 };
 
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 
 use polkadot_node_network_protocol::{
 	self as net_protocol,
@@ -367,7 +367,7 @@ impl ActiveParas {
 	async fn assign_incoming(
 		&mut self,
 		sender: &mut impl SubsystemSender<RuntimeApiMessage>,
-		keystore: &SyncCryptoStorePtr,
+		keystore: &KeystorePtr,
 		new_relay_parents: impl IntoIterator<Item = Hash>,
 	) {
 		for relay_parent in new_relay_parents {
@@ -404,7 +404,6 @@ impl ActiveParas {
 
 			let para_now =
 				match polkadot_node_subsystem_util::signing_key_and_index(&validators, keystore)
-					.await
 					.and_then(|(_, index)| {
 						polkadot_node_subsystem_util::find_validator_group(&groups, index)
 					}) {
@@ -993,7 +992,7 @@ async fn remove_relay_parent(state: &mut State, relay_parent: Hash) -> Result<()
 async fn handle_our_view_change<Context>(
 	ctx: &mut Context,
 	state: &mut State,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	view: OurView,
 ) -> Result<()> {
 	let old_view = std::mem::replace(&mut state.view, view);
@@ -1049,7 +1048,7 @@ async fn handle_our_view_change<Context>(
 async fn handle_network_msg<Context>(
 	ctx: &mut Context,
 	state: &mut State,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	bridge_message: NetworkBridgeEvent<net_protocol::CollatorProtocolMessage>,
 ) -> Result<()> {
 	use NetworkBridgeEvent::*;
@@ -1084,7 +1083,7 @@ async fn handle_network_msg<Context>(
 #[overseer::contextbounds(CollatorProtocol, prefix = self::overseer)]
 async fn process_msg<Context>(
 	ctx: &mut Context,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	msg: CollatorProtocolMessage,
 	state: &mut State,
 ) {
@@ -1165,7 +1164,7 @@ async fn process_msg<Context>(
 #[overseer::contextbounds(CollatorProtocol, prefix = self::overseer)]
 pub(crate) async fn run<Context>(
 	mut ctx: Context,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	eviction_policy: crate::CollatorEvictionPolicy,
 	metrics: Metrics,
 ) -> std::result::Result<(), crate::error::FatalError> {

polkadot/node/network/collator-protocol/src/validator_side/tests.rs

@@ -19,7 +19,7 @@ use assert_matches::assert_matches;
 use futures::{executor, future, Future};
 use sp_core::{crypto::Pair, Encode};
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::{testing::KeyStore as TestKeyStore, SyncCryptoStore};
+use sp_keystore::{testing::MemoryKeystore, Keystore};
 use std::{iter, sync::Arc, task::Poll, time::Duration};
 
 use polkadot_node_network_protocol::{
@@ -130,7 +130,7 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(test: impl FnOnce(TestHarne
 
 	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
 
-	let keystore = TestKeyStore::new();
+	let keystore = MemoryKeystore::new();
 	keystore
 		.sr25519_generate_new(
 			polkadot_primitives::PARACHAIN_KEY_TYPE_ID,

polkadot/node/network/dispute-distribution/src/lib.rs

@@ -30,7 +30,7 @@ use futures::{channel::mpsc, FutureExt, StreamExt, TryFutureExt};
 
 use polkadot_node_network_protocol::authority_discovery::AuthorityDiscovery;
 use polkadot_node_subsystem_util::nesting_sender::NestingSender;
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 
 use polkadot_node_network_protocol::request_response::{incoming::IncomingRequestReceiver, v1};
 use polkadot_node_primitives::DISPUTE_WINDOW;
@@ -158,7 +158,7 @@ where
 {
 	/// Create a new instance of the dispute distribution.
 	pub fn new(
-		keystore: SyncCryptoStorePtr,
+		keystore: KeystorePtr,
 		req_receiver: IncomingRequestReceiver<v1::DisputeRequest>,
 		authority_discovery: AD,
 		metrics: Metrics,

polkadot/node/network/dispute-distribution/src/tests/mock.rs

@@ -30,7 +30,7 @@ use polkadot_node_network_protocol::{authority_discovery::AuthorityDiscovery, Pe
 use sc_keystore::LocalKeystore;
 use sp_application_crypto::AppKey;
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
+use sp_keystore::{Keystore, KeystorePtr};
 
 use polkadot_node_primitives::{DisputeMessage, SignedDisputeStatement};
 use polkadot_primitives::{
@@ -126,13 +126,13 @@ pub fn make_candidate_receipt(relay_parent: Hash) -> CandidateReceipt {
 	}
 }
 
-pub async fn make_explicit_signed(
+pub fn make_explicit_signed(
 	validator: Sr25519Keyring,
 	candidate_hash: CandidateHash,
 	valid: bool,
 ) -> SignedDisputeStatement {
-	let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-	SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, Some(&validator.to_seed()))
+	let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+	Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, Some(&validator.to_seed()))
 		.expect("Insert key into keystore");
 
 	SignedDisputeStatement::sign_explicit(
@@ -142,12 +142,11 @@ pub async fn make_explicit_signed(
 		MOCK_SESSION_INDEX,
 		validator.public().into(),
 	)
-	.await
 	.expect("Keystore should be fine.")
 	.expect("Signing should work.")
 }
 
-pub async fn make_dispute_message(
+pub fn make_dispute_message(
 	candidate: CandidateReceipt,
 	valid_validator: ValidatorIndex,
 	invalid_validator: ValidatorIndex,
@@ -155,16 +154,14 @@ pub async fn make_dispute_message(
 	let candidate_hash = candidate.hash();
 	let before_request = Instant::now();
 	let valid_vote =
-		make_explicit_signed(MOCK_VALIDATORS[valid_validator.0 as usize], candidate_hash, true)
-			.await;
+		make_explicit_signed(MOCK_VALIDATORS[valid_validator.0 as usize], candidate_hash, true);
 	gum::trace!(
 		"Passed time for valid vote: {:#?}",
 		Instant::now().saturating_duration_since(before_request)
 	);
 	let before_request = Instant::now();
 	let invalid_vote =
-		make_explicit_signed(MOCK_VALIDATORS[invalid_validator.0 as usize], candidate_hash, false)
-			.await;
+		make_explicit_signed(MOCK_VALIDATORS[invalid_validator.0 as usize], candidate_hash, false);
 	gum::trace!(
 		"Passed time for invald vote: {:#?}",
 		Instant::now().saturating_duration_since(before_request)

polkadot/node/network/dispute-distribution/src/tests/mod.rs

@@ -123,7 +123,7 @@ async fn send_dispute(
 	needs_session_info: bool,
 ) {
 	let before_request = Instant::now();
-	let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+	let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX);
 	gum::trace!(
 		"Passed time for making message: {:#?}",
 		Instant::now().saturating_duration_since(before_request)
@@ -190,7 +190,7 @@ fn received_non_authorities_are_dropped() {
 
 		let relay_parent = Hash::random();
 		let candidate = make_candidate_receipt(relay_parent);
-		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX);
 
 		// Non validator request should get dropped:
 		let rx_response =
@@ -222,7 +222,7 @@ fn received_request_triggers_import() {
 
 		let relay_parent = Hash::random();
 		let candidate = make_candidate_receipt(relay_parent);
-		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX);
 
 		nested_network_dispute_request(
 			&mut handle,
@@ -250,7 +250,7 @@ fn batching_works() {
 
 		let relay_parent = Hash::random();
 		let candidate = make_candidate_receipt(relay_parent);
-		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX);
 
 		// Initial request should get forwarded immediately:
 		nested_network_dispute_request(
@@ -266,27 +266,27 @@ fn batching_works() {
 
 		let mut rx_responses = Vec::new();
 
-		let message = make_dispute_message(candidate.clone(), BOB_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), BOB_INDEX, FERDIE_INDEX);
 		let peer = MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob);
 		rx_responses.push(send_network_dispute_request(req_tx, peer, message.clone().into()).await);
 
-		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, FERDIE_INDEX);
 		let peer = MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Charlie);
 		rx_responses.push(send_network_dispute_request(req_tx, peer, message.clone().into()).await);
 		gum::trace!("Imported 3 votes into batch");
 
-		Delay::new(BATCH_COLLECTING_INTERVAL).await;
+		Delay::new(BATCH_COLLECTING_INTERVAL);
 		gum::trace!("Batch should still be alive");
 		// Batch should still be alive (2 new votes):
 		// Let's import two more votes, but fully duplicates - should not extend batch live.
 		gum::trace!("Importing duplicate votes");
 		let mut rx_responses_duplicate = Vec::new();
-		let message = make_dispute_message(candidate.clone(), BOB_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), BOB_INDEX, FERDIE_INDEX);
 		let peer = MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob);
 		rx_responses_duplicate
 			.push(send_network_dispute_request(req_tx, peer, message.clone().into()).await);
 
-		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, FERDIE_INDEX);
 		let peer = MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Charlie);
 		rx_responses_duplicate
 			.push(send_network_dispute_request(req_tx, peer, message.clone().into()).await);
@@ -375,7 +375,7 @@ fn receive_rate_limit_is_enforced() {
 
 		let relay_parent = Hash::random();
 		let candidate = make_candidate_receipt(relay_parent);
-		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX);
 
 		// Initial request should get forwarded immediately:
 		nested_network_dispute_request(
@@ -393,15 +393,15 @@ fn receive_rate_limit_is_enforced() {
 
 		let peer = MOCK_AUTHORITY_DISCOVERY.get_peer_id_by_authority(Sr25519Keyring::Bob);
 
-		let message = make_dispute_message(candidate.clone(), BOB_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), BOB_INDEX, FERDIE_INDEX);
 		rx_responses.push(send_network_dispute_request(req_tx, peer, message.clone().into()).await);
 
-		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, FERDIE_INDEX);
 		rx_responses.push(send_network_dispute_request(req_tx, peer, message.clone().into()).await);
 
 		gum::trace!("Import one too much:");
 
-		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, ALICE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), CHARLIE_INDEX, ALICE_INDEX);
 		let rx_response_flood =
 			send_network_dispute_request(req_tx, peer, message.clone().into()).await;
 
@@ -486,7 +486,7 @@ fn send_dispute_gets_cleaned_up() {
 
 		let relay_parent = Hash::random();
 		let candidate = make_candidate_receipt(relay_parent);
-		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX);
 		handle
 			.send(FromOrchestra::Communication {
 				msg: DisputeDistributionMessage::SendDispute(message.clone()),
@@ -552,7 +552,7 @@ fn dispute_retries_and_works_across_session_boundaries() {
 
 		let relay_parent = Hash::random();
 		let candidate = make_candidate_receipt(relay_parent);
-		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX).await;
+		let message = make_dispute_message(candidate.clone(), ALICE_INDEX, FERDIE_INDEX);
 		handle
 			.send(FromOrchestra::Communication {
 				msg: DisputeDistributionMessage::SendDispute(message.clone()),

polkadot/node/network/gossip-support/src/lib.rs

@@ -37,7 +37,7 @@ use rand_chacha::ChaCha20Rng;
 
 use sc_network::Multiaddr;
 use sp_application_crypto::{AppKey, ByteArray};
-use sp_keystore::{CryptoStore, SyncCryptoStorePtr};
+use sp_keystore::{Keystore, KeystorePtr};
 
 use polkadot_node_network_protocol::{
 	authority_discovery::AuthorityDiscovery, peer_set::PeerSet, GossipSupportNetworkMessage,
@@ -79,7 +79,7 @@ const LOW_CONNECTIVITY_WARN_THRESHOLD: usize = 90;
 
 /// The Gossip Support subsystem.
 pub struct GossipSupport<AD> {
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 
 	last_session_index: Option<SessionIndex>,
 	// Some(timestamp) if we failed to resolve
@@ -118,7 +118,7 @@ where
 	AD: AuthorityDiscovery,
 {
 	/// Create a new instance of the [`GossipSupport`] subsystem.
-	pub fn new(keystore: SyncCryptoStorePtr, authority_discovery: AD, metrics: Metrics) -> Self {
+	pub fn new(keystore: KeystorePtr, authority_discovery: AD, metrics: Metrics) -> Self {
 		// Initialize metrics to `0`.
 		metrics.on_is_not_authority();
 		metrics.on_is_not_parachain_validator();
@@ -248,7 +248,7 @@ where
 
 					// Remove all of our locally controlled validator indices so we don't connect to ourself.
 					let connections =
-						if remove_all_controlled(&self.keystore, &mut connections).await != 0 {
+						if remove_all_controlled(&self.keystore, &mut connections) != 0 {
 							connections
 						} else {
 							// If we control none of them, issue an empty connection request
@@ -260,7 +260,7 @@ where
 
 				if is_new_session {
 					// Gossip topology is only relevant for authorities in the current session.
-					let our_index = self.get_key_index_and_update_metrics(&session_info).await?;
+					let our_index = self.get_key_index_and_update_metrics(&session_info)?;
 
 					update_gossip_topology(
 						sender,
@@ -279,12 +279,12 @@ where
 	// Checks if the node is an authority and also updates `polkadot_node_is_authority` and
 	// `polkadot_node_is_parachain_validator` metrics accordingly.
 	// On success, returns the index of our keys in `session_info.discovery_keys`.
-	async fn get_key_index_and_update_metrics(
+	fn get_key_index_and_update_metrics(
 		&mut self,
 		session_info: &SessionInfo,
 	) -> Result<usize, util::Error> {
 		let authority_check_result =
-			ensure_i_am_an_authority(&self.keystore, &session_info.discovery_keys).await;
+			ensure_i_am_an_authority(&self.keystore, &session_info.discovery_keys);
 
 		match authority_check_result.as_ref() {
 			Ok(index) => {
@@ -457,12 +457,12 @@ async fn authorities_past_present_future(
 
 /// Return an error if we're not a validator in the given set (do not have keys).
 /// Otherwise, returns the index of our keys in `authorities`.
-async fn ensure_i_am_an_authority(
-	keystore: &SyncCryptoStorePtr,
+fn ensure_i_am_an_authority(
+	keystore: &KeystorePtr,
 	authorities: &[AuthorityDiscoveryId],
 ) -> Result<usize, util::Error> {
 	for (i, v) in authorities.iter().enumerate() {
-		if CryptoStore::has_keys(&**keystore, &[(v.to_raw_vec(), AuthorityDiscoveryId::ID)]).await {
+		if Keystore::has_keys(&**keystore, &[(v.to_raw_vec(), AuthorityDiscoveryId::ID)]) {
 			return Ok(i)
 		}
 	}
@@ -470,13 +470,13 @@ async fn ensure_i_am_an_authority(
 }
 
 /// Filter out all controlled keys in the given set. Returns the number of keys removed.
-async fn remove_all_controlled(
-	keystore: &SyncCryptoStorePtr,
+fn remove_all_controlled(
+	keystore: &KeystorePtr,
 	authorities: &mut Vec<AuthorityDiscoveryId>,
 ) -> usize {
 	let mut to_remove = Vec::new();
 	for (i, v) in authorities.iter().enumerate() {
-		if CryptoStore::has_keys(&**keystore, &[(v.to_raw_vec(), AuthorityDiscoveryId::ID)]).await {
+		if Keystore::has_keys(&**keystore, &[(v.to_raw_vec(), AuthorityDiscoveryId::ID)]) {
 			to_remove.push(i);
 		}
 	}

polkadot/node/network/statement-distribution/src/lib.rs

@@ -57,7 +57,7 @@ use futures::{
 	prelude::*,
 };
 use indexmap::{map::Entry as IEntry, IndexMap};
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 use util::runtime::RuntimeInfo;
 
 use std::collections::{hash_map::Entry, HashMap, HashSet, VecDeque};
@@ -119,7 +119,7 @@ const MAX_LARGE_STATEMENTS_PER_SENDER: usize = 20;
 /// The statement distribution subsystem.
 pub struct StatementDistributionSubsystem<R> {
 	/// Pointer to a keystore, which is required for determining this node's validator index.
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	/// Receiver for incoming large statement requests.
 	req_receiver: Option<IncomingRequestReceiver<request_v1::StatementFetchingRequest>>,
 	/// Prometheus metrics
@@ -1745,7 +1745,7 @@ async fn handle_network_update<Context, R>(
 impl<R: rand::Rng> StatementDistributionSubsystem<R> {
 	/// Create a new Statement Distribution Subsystem
 	pub fn new(
-		keystore: SyncCryptoStorePtr,
+		keystore: KeystorePtr,
 		req_receiver: IncomingRequestReceiver<request_v1::StatementFetchingRequest>,
 		metrics: Metrics,
 		rng: R,

polkadot/node/network/statement-distribution/src/tests.rs

@@ -16,7 +16,7 @@
 
 use super::{metrics::Metrics, *};
 use assert_matches::assert_matches;
-use futures::executor::{self, block_on};
+use futures::executor;
 use futures_timer::Delay;
 use parity_scale_codec::{Decode, Encode};
 use polkadot_node_network_protocol::{
@@ -45,7 +45,7 @@ use sc_keystore::LocalKeystore;
 use sp_application_crypto::{sr25519::Pair, AppKey, Pair as TraitPair};
 use sp_authority_discovery::AuthorityPair;
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::{CryptoStore, SyncCryptoStore, SyncCryptoStorePtr};
+use sp_keystore::{Keystore, KeystorePtr};
 use std::{iter::FromIterator as _, sync::Arc, time::Duration};
 
 // Some deterministic genesis hash for protocol names
@@ -90,14 +90,14 @@ fn active_head_accepts_only_2_seconded_per_validator() {
 		PerLeafSpan::new(Arc::new(jaeger::Span::Disabled), "test"),
 	);
 
-	let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-	let alice_public = SyncCryptoStore::sr25519_generate_new(
+	let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+	let alice_public = Keystore::sr25519_generate_new(
 		&*keystore,
 		ValidatorId::ID,
 		Some(&Sr25519Keyring::Alice.to_seed()),
 	)
 	.unwrap();
-	let bob_public = SyncCryptoStore::sr25519_generate_new(
+	let bob_public = Keystore::sr25519_generate_new(
 		&*keystore,
 		ValidatorId::ID,
 		Some(&Sr25519Keyring::Bob.to_seed()),
@@ -105,13 +105,13 @@ fn active_head_accepts_only_2_seconded_per_validator() {
 	.unwrap();
 
 	// note A
-	let a_seconded_val_0 = block_on(SignedFullStatement::sign(
+	let a_seconded_val_0 = SignedFullStatement::sign(
 		&keystore,
 		Statement::Seconded(candidate_a.clone()),
 		&signing_context,
 		ValidatorIndex(0),
 		&alice_public.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -132,13 +132,13 @@ fn active_head_accepts_only_2_seconded_per_validator() {
 	assert_matches!(noted, NotedStatement::UsefulButKnown);
 
 	// note B
-	let statement = block_on(SignedFullStatement::sign(
+	let statement = SignedFullStatement::sign(
 		&keystore,
 		Statement::Seconded(candidate_b.clone()),
 		&signing_context,
 		ValidatorIndex(0),
 		&alice_public.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -149,13 +149,13 @@ fn active_head_accepts_only_2_seconded_per_validator() {
 	assert_matches!(noted, NotedStatement::Fresh(_));
 
 	// note C (beyond 2 - ignored)
-	let statement = block_on(SignedFullStatement::sign(
+	let statement = SignedFullStatement::sign(
 		&keystore,
 		Statement::Seconded(candidate_c.clone()),
 		&signing_context,
 		ValidatorIndex(0),
 		&alice_public.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -167,13 +167,13 @@ fn active_head_accepts_only_2_seconded_per_validator() {
 	assert_matches!(noted, NotedStatement::NotUseful);
 
 	// note B (new validator)
-	let statement = block_on(SignedFullStatement::sign(
+	let statement = SignedFullStatement::sign(
 		&keystore,
 		Statement::Seconded(candidate_b.clone()),
 		&signing_context,
 		ValidatorIndex(1),
 		&bob_public.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -184,13 +184,13 @@ fn active_head_accepts_only_2_seconded_per_validator() {
 	assert_matches!(noted, NotedStatement::Fresh(_));
 
 	// note C (new validator)
-	let statement = block_on(SignedFullStatement::sign(
+	let statement = SignedFullStatement::sign(
 		&keystore,
 		Statement::Seconded(candidate_c.clone()),
 		&signing_context,
 		ValidatorIndex(1),
 		&bob_public.into(),
-	))
+	)
 	.ok()
 	.flatten()
 	.expect("should be signed");
@@ -408,21 +408,21 @@ fn peer_view_update_sends_messages() {
 	let session_index = 1;
 	let signing_context = SigningContext { parent_hash: hash_c, session_index };
 
-	let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
+	let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
 
-	let alice_public = SyncCryptoStore::sr25519_generate_new(
+	let alice_public = Keystore::sr25519_generate_new(
 		&*keystore,
 		ValidatorId::ID,
 		Some(&Sr25519Keyring::Alice.to_seed()),
 	)
 	.unwrap();
-	let bob_public = SyncCryptoStore::sr25519_generate_new(
+	let bob_public = Keystore::sr25519_generate_new(
 		&*keystore,
 		ValidatorId::ID,
 		Some(&Sr25519Keyring::Bob.to_seed()),
 	)
 	.unwrap();
-	let charlie_public = SyncCryptoStore::sr25519_generate_new(
+	let charlie_public = Keystore::sr25519_generate_new(
 		&*keystore,
 		ValidatorId::ID,
 		Some(&Sr25519Keyring::Charlie.to_seed()),
@@ -436,13 +436,13 @@ fn peer_view_update_sends_messages() {
 			PerLeafSpan::new(Arc::new(jaeger::Span::Disabled), "test"),
 		);
 
-		let statement = block_on(SignedFullStatement::sign(
+		let statement = SignedFullStatement::sign(
 			&keystore,
 			Statement::Seconded(candidate.clone()),
 			&signing_context,
 			ValidatorIndex(0),
 			&alice_public.into(),
-		))
+		)
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -453,13 +453,13 @@ fn peer_view_update_sends_messages() {
 
 		assert_matches!(noted, NotedStatement::Fresh(_));
 
-		let statement = block_on(SignedFullStatement::sign(
+		let statement = SignedFullStatement::sign(
 			&keystore,
 			Statement::Valid(candidate_hash),
 			&signing_context,
 			ValidatorIndex(1),
 			&bob_public.into(),
-		))
+		)
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -470,13 +470,13 @@ fn peer_view_update_sends_messages() {
 
 		assert_matches!(noted, NotedStatement::Fresh(_));
 
-		let statement = block_on(SignedFullStatement::sign(
+		let statement = SignedFullStatement::sign(
 			&keystore,
 			Statement::Valid(candidate_hash),
 			&signing_context,
 			ValidatorIndex(2),
 			&charlie_public.into(),
-		))
+		)
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -614,13 +614,12 @@ fn circulated_statement_goes_to_all_peers_with_view() {
 	executor::block_on(async move {
 		let signing_context = SigningContext { parent_hash: hash_b, session_index };
 
-		let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-		let alice_public = CryptoStore::sr25519_generate_new(
+		let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+		let alice_public = Keystore::sr25519_generate_new(
 			&*keystore,
 			ValidatorId::ID,
 			Some(&Sr25519Keyring::Alice.to_seed()),
 		)
-		.await
 		.unwrap();
 
 		let statement = SignedFullStatement::sign(
@@ -630,7 +629,6 @@ fn circulated_statement_goes_to_all_peers_with_view() {
 			ValidatorIndex(0),
 			&alice_public.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -827,13 +825,12 @@ fn receiving_from_one_sends_to_another_and_to_candidate_backing() {
 		let statement = {
 			let signing_context = SigningContext { parent_hash: hash_a, session_index };
 
-			let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-			let alice_public = CryptoStore::sr25519_generate_new(
+			let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+			let alice_public = Keystore::sr25519_generate_new(
 				&*keystore,
 				ValidatorId::ID,
 				Some(&Sr25519Keyring::Alice.to_seed()),
 			)
-			.await
 			.unwrap();
 
 			SignedFullStatement::sign(
@@ -843,7 +840,6 @@ fn receiving_from_one_sends_to_another_and_to_candidate_backing() {
 				ValidatorIndex(0),
 				&alice_public.into(),
 			)
-			.await
 			.ok()
 			.flatten()
 			.expect("should be signed")
@@ -1071,13 +1067,12 @@ fn receiving_large_statement_from_one_sends_to_another_and_to_candidate_backing(
 		let statement = {
 			let signing_context = SigningContext { parent_hash: hash_a, session_index };
 
-			let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-			let alice_public = CryptoStore::sr25519_generate_new(
+			let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+			let alice_public = Keystore::sr25519_generate_new(
 				&*keystore,
 				ValidatorId::ID,
 				Some(&Sr25519Keyring::Alice.to_seed()),
 			)
-			.await
 			.unwrap();
 
 			SignedFullStatement::sign(
@@ -1087,7 +1082,6 @@ fn receiving_large_statement_from_one_sends_to_another_and_to_candidate_backing(
 				ValidatorIndex(0),
 				&alice_public.into(),
 			)
-			.await
 			.ok()
 			.flatten()
 			.expect("should be signed")
@@ -1627,13 +1621,12 @@ fn share_prioritizes_backing_group() {
 		let statement = {
 			let signing_context = SigningContext { parent_hash: hash_a, session_index };
 
-			let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-			let ferdie_public = CryptoStore::sr25519_generate_new(
+			let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+			let ferdie_public = Keystore::sr25519_generate_new(
 				&*keystore,
 				ValidatorId::ID,
 				Some(&Sr25519Keyring::Ferdie.to_seed()),
 			)
-			.await
 			.unwrap();
 
 			SignedFullStatement::sign(
@@ -1643,7 +1636,6 @@ fn share_prioritizes_backing_group() {
 				ValidatorIndex(4),
 				&ferdie_public.into(),
 			)
-			.await
 			.ok()
 			.flatten()
 			.expect("should be signed")
@@ -1819,13 +1811,12 @@ fn peer_cant_flood_with_large_statements() {
 		let statement = {
 			let signing_context = SigningContext { parent_hash: hash_a, session_index };
 
-			let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-			let alice_public = CryptoStore::sr25519_generate_new(
+			let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+			let alice_public = Keystore::sr25519_generate_new(
 				&*keystore,
 				ValidatorId::ID,
 				Some(&Sr25519Keyring::Alice.to_seed()),
 			)
-			.await
 			.unwrap();
 
 			SignedFullStatement::sign(
@@ -1835,7 +1826,6 @@ fn peer_cant_flood_with_large_statements() {
 				ValidatorIndex(0),
 				&alice_public.into(),
 			)
-			.await
 			.ok()
 			.flatten()
 			.expect("should be signed")
@@ -2108,13 +2098,12 @@ fn handle_multiple_seconded_statements() {
 		let statement = {
 			let signing_context = SigningContext { parent_hash: relay_parent_hash, session_index };
 
-			let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-			let alice_public = CryptoStore::sr25519_generate_new(
+			let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+			let alice_public = Keystore::sr25519_generate_new(
 				&*keystore,
 				ValidatorId::ID,
 				Some(&Sr25519Keyring::Alice.to_seed()),
 			)
-			.await
 			.unwrap();
 
 			SignedFullStatement::sign(
@@ -2124,7 +2113,6 @@ fn handle_multiple_seconded_statements() {
 				ValidatorIndex(0),
 				&alice_public.into(),
 			)
-			.await
 			.ok()
 			.flatten()
 			.expect("should be signed")
@@ -2211,13 +2199,12 @@ fn handle_multiple_seconded_statements() {
 		let statement = {
 			let signing_context = SigningContext { parent_hash: relay_parent_hash, session_index };
 
-			let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::in_memory());
-			let alice_public = CryptoStore::sr25519_generate_new(
+			let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+			let alice_public = Keystore::sr25519_generate_new(
 				&*keystore,
 				ValidatorId::ID,
 				Some(&Sr25519Keyring::Alice.to_seed()),
 			)
-			.await
 			.unwrap();
 
 			SignedFullStatement::sign(
@@ -2227,7 +2214,6 @@ fn handle_multiple_seconded_statements() {
 				ValidatorIndex(0),
 				&alice_public.into(),
 			)
-			.await
 			.ok()
 			.flatten()
 			.expect("should be signed")