Refactor key management (#3296)

* Add Call type to extensible transactions.

Cleanup some naming

* Merge Resource and BlockExhausted into just Exhausted

* Fix

* Another fix

* Call

* Some fixes

* Fix srml tests.

* Fix all tests.

* Refactor crypto so each application of it has its own type.

* Introduce new AuthorityProvider API into Aura

This will eventually allow for dynamic determination of authority
keys and avoid having to set them directly on CLI.

* Introduce authority determinator for Babe.

Experiment with modular consensus API.

* Work in progress to introduce KeyTypeId and avoid polluting API
with validator IDs

* Finish up drafting imonline

* Rework offchain workers API.

* Rework API implementation.

* Make it compile for wasm, simplify app_crypto.

* Fix compilation of im-online.

* Fix compilation of im-online.

* Fix more compilation errors.

* Make it compile.

* Fixing tests.

* Rewrite `keystore`

* Fix session tests

* Bring back `TryFrom`'s'

* Fix `srml-grandpa`

* Fix `srml-aura`

* Fix consensus babe

* More fixes

* Make service generate keys from dev_seed

* Build fixes

* Remove offchain tests

* More fixes and cleanups

* Fixes finality grandpa

* Fix `consensus-aura`

* Fix cli

* Fix `node-cli`

* Fix chain_spec builder

* Fix doc tests

* Add authority getter for grandpa.

* Test fix

* Fixes

* Make keystore accessible from the runtime

* Move app crypto to its own crate

* Update `Cargo.lock`

* Make the crypto stuff usable from the runtime

* Adds some runtime crypto tests

* Use last finalized block for grandpa authority

* Fix warning

* Adds `SessionKeys` runtime api

* Remove `FinalityPair` and `ConsensusPair`

* Minor governance tweaks to get it inline with docs.

* Make the governance be up to date with the docs.

* Build fixes.

* Generate the inital session keys

* Failing keystore is a hard error

* Make babe work again

* Fix grandpa

* Fix tests

* Disable `keystore` in consensus critical stuff

* Build fix.

* ImOnline supports multiple authorities at once.

* Update core/application-crypto/src/ed25519.rs

* Merge branch 'master' into gav-in-progress

* Remove unneeded code for now.

* Some `session` testing

* Support querying the public keys

* Cleanup offchain

* Remove warnings

* More cleanup

* Apply suggestions from code review

Co-Authored-By: Benjamin Kampmann <ben.kampmann@googlemail.com>

* More cleanups

* JSONRPC API for setting keys.

Also, rename traits::KeyStore* -> traits::BareCryptoStore*

* Bad merge

* Fix integration tests

* Fix test build

* Test fix

* Fixes

* Warnings

* Another warning

* Bump version.

substrate/core/offchain/src/lib.rs

@@ -40,18 +40,12 @@ use std::{
 };
 
 use client::runtime_api::ApiExt;
-use log::{debug, warn};
-use primitives::{
-	ExecutionContext,
-	crypto,
-};
-use sr_primitives::{
-	generic::BlockId,
-	traits::{self, ProvideRuntimeApi},
-};
 use futures::future::Future;
-use transaction_pool::txpool::{Pool, ChainApi};
+use log::{debug, warn};
 use network::NetworkStateInfo;
+use primitives::ExecutionContext;
+use sr_primitives::{generic::BlockId, traits::{self, ProvideRuntimeApi}};
+use transaction_pool::txpool::{Pool, ChainApi};
 
 mod api;
 
@@ -59,61 +53,27 @@ pub mod testing;
 
 pub use offchain_primitives::OffchainWorkerApi;
 
-/// Provides currently configured authority key.
-pub trait AuthorityKeyProvider<Block: traits::Block>: Clone + 'static {
-	/// The crypto used by the block authoring algorithm.
-	type ConsensusPair: crypto::Pair;
-	/// The crypto used by the finality gadget.
-	type FinalityPair: crypto::Pair;
-
-	/// Returns currently configured authority key.
-	fn authority_key(&self, block_id: &BlockId<Block>) -> Option<Self::ConsensusPair>;
-
-	/// Returns currently configured finality gadget authority key.
-	fn fg_authority_key(&self, block_id: &BlockId<Block>) -> Option<Self::FinalityPair>;
-}
-
 /// An offchain workers manager.
-pub struct OffchainWorkers<
-	Client,
-	Storage,
-	KeyProvider,
-	Block: traits::Block,
-> {
+pub struct OffchainWorkers<Client, Storage, Block: traits::Block> {
 	client: Arc<Client>,
 	db: Storage,
-	authority_key: KeyProvider,
-	keys_password: crypto::Protected<String>,
 	_block: PhantomData<Block>,
 }
 
-impl<Client, Storage, KeyProvider, Block: traits::Block> OffchainWorkers<
-	Client,
-	Storage,
-	KeyProvider,
-	Block,
-> {
+impl<Client, Storage, Block: traits::Block> OffchainWorkers<Client, Storage, Block> {
 	/// Creates new `OffchainWorkers`.
-	pub fn new(
-		client: Arc<Client>,
-		db: Storage,
-		authority_key: KeyProvider,
-		keys_password: crypto::Protected<String>,
-	) -> Self {
+	pub fn new(client: Arc<Client>, db: Storage) -> Self {
 		Self {
 			client,
 			db,
-			authority_key,
-			keys_password,
 			_block: PhantomData,
 		}
 	}
 }
 
-impl<Client, Storage, KeyProvider, Block: traits::Block> fmt::Debug for OffchainWorkers<
+impl<Client, Storage, Block: traits::Block> fmt::Debug for OffchainWorkers<
 	Client,
 	Storage,
-	KeyProvider,
 	Block,
 > {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -121,16 +81,14 @@ impl<Client, Storage, KeyProvider, Block: traits::Block> fmt::Debug for Offchain
 	}
 }
 
-impl<Client, Storage, KeyProvider, Block> OffchainWorkers<
+impl<Client, Storage, Block> OffchainWorkers<
 	Client,
 	Storage,
-	KeyProvider,
 	Block,
 > where
 	Block: traits::Block,
 	Client: ProvideRuntimeApi + Send + Sync + 'static,
 	Client::Api: OffchainWorkerApi<Block>,
-	KeyProvider: AuthorityKeyProvider<Block> + Send,
 	Storage: client::backend::OffchainStorage + 'static,
 {
 	/// Start the offchain workers after given block.
@@ -152,8 +110,6 @@ impl<Client, Storage, KeyProvider, Block> OffchainWorkers<
 			let (api, runner) = api::AsyncApi::new(
 				pool.clone(),
 				self.db.clone(),
-				self.keys_password.clone(),
-				self.authority_key.clone(),
 				at.clone(),
 				network_state.clone(),
 			);
@@ -167,7 +123,7 @@ impl<Client, Storage, KeyProvider, Block> OffchainWorkers<
 				let run = runtime.offchain_worker_with_context(
 					&at,
 					ExecutionContext::OffchainWorker(api),
-					number
+					number,
 				);
 				if let Err(e) =	run {
 					log::error!("Error running offchain workers at {:?}: {:?}", at, e);
@@ -197,7 +153,6 @@ fn spawn_worker(f: impl FnOnce() -> () + Send + 'static) {
 mod tests {
 	use super::*;
 	use futures::Future;
-	use primitives::{ed25519, sr25519};
 	use network::{Multiaddr, PeerId};
 
 	struct MockNetworkStateInfo();
@@ -212,49 +167,19 @@ mod tests {
 		}
 	}
 
-	#[derive(Clone)]
-	pub(crate) struct TestProvider<Block> {
-		_marker: PhantomData<Block>,
-		pub(crate) sr_key: Option<sr25519::Pair>,
-		pub(crate) ed_key: Option<ed25519::Pair>,
-	}
-
-	impl<Block: traits::Block> Default for TestProvider<Block> {
-		fn default() -> Self {
-			Self {
-				_marker: PhantomData,
-				sr_key: None,
-				ed_key: None,
-			}
-		}
-	}
-
-	impl<Block: traits::Block> AuthorityKeyProvider<Block> for TestProvider<Block> {
-		type ConsensusPair = ed25519::Pair;
-		type FinalityPair = sr25519::Pair;
-
-		fn authority_key(&self, _: &BlockId<Block>) -> Option<Self::ConsensusPair> {
-			self.ed_key.clone()
-		}
-
-		fn fg_authority_key(&self, _: &BlockId<Block>) -> Option<Self::FinalityPair> {
-			self.sr_key.clone()
-		}
-	}
-
 	#[test]
 	fn should_call_into_runtime_and_produce_extrinsic() {
 		// given
 		let _ = env_logger::try_init();
 		let runtime = tokio::runtime::Runtime::new().unwrap();
 		let client = Arc::new(test_client::new());
-		let pool = Arc::new(Pool::new(Default::default(), ::transaction_pool::ChainApi::new(client.clone())));
+		let pool = Arc::new(Pool::new(Default::default(), transaction_pool::ChainApi::new(client.clone())));
 		let db = client_db::offchain::LocalStorage::new_test();
-		let mock = Arc::new(MockNetworkStateInfo());
+		let network_state = Arc::new(MockNetworkStateInfo());
 
 		// when
-		let offchain = OffchainWorkers::new(client, db, TestProvider::default(), "".to_owned().into());
-		runtime.executor().spawn(offchain.on_block_imported(&0u64, &pool, mock.clone()));
+		let offchain = OffchainWorkers::new(client, db);
+		runtime.executor().spawn(offchain.on_block_imported(&0u64, &pool, network_state.clone()));
 
 		// then
 		runtime.shutdown_on_idle().wait().unwrap();