Consensus Engines Implementation: Aura (#911)

* Generalize BlockImport

 - move ImportBlock, BlockOrigin, ImportResult into shared sr-primitives
 - let Consensus provide  and  traits again
 - update consensus traits to latest development
 - implement traits on client::Client, test_client::TestClient
 - update RHD to use the new import_block API

* Move ImportBlock into consensus-common
* Send import notification in aura tests
* Integrating aura into service
* Make Signatures more generic
* Aura Block Production with the given key
* run aura on the thread pool
* start at exact step start in aura
* Add needed wasm blob, in leiu of better solutions.
* Make API ids consistent with traits and bring upstream for sharing.
* Add decrease_free_balance to Balances module
* Encode `Metadata` once instead of two times
* Bitops include xor
* Upgrade key module.
* Default pages to somewhat bigger.
* Introduce upgrade key into node
* Add `Created` event

substrate/node/cli/src/chain_spec.rs

@@ -17,8 +17,9 @@
 //! Substrate chain configurations.
 
 use primitives::{AuthorityId, ed25519};
+use node_primitives::AccountId;
 use node_runtime::{GenesisConfig, ConsensusConfig, CouncilSeatsConfig, CouncilVotingConfig, DemocracyConfig,
-	SessionConfig, StakingConfig, TimestampConfig, BalancesConfig, TreasuryConfig,
+	SessionConfig, StakingConfig, TimestampConfig, BalancesConfig, TreasuryConfig, UpgradeKeyConfig,
 	ContractConfig, Permill, Perbill};
 use substrate_service;
 
@@ -45,7 +46,7 @@ fn staging_testnet_config_genesis() -> GenesisConfig {
 	const CENTS: u128 = 1_000 * MILLICENTS;	// assume this is worth about a cent.
 	const DOLLARS: u128 = 100 * CENTS;
 
-	const SECS_PER_BLOCK: u64 = 5;
+	const SECS_PER_BLOCK: u64 = 4;
 	const MINUTES: u64 = 60 / SECS_PER_BLOCK;
 	const HOURS: u64 = MINUTES * 60;
 	const DAYS: u64 = HOURS * 24;
@@ -121,6 +122,9 @@ fn staging_testnet_config_genesis() -> GenesisConfig {
 			max_depth: 1024,
 			block_gas_limit: 10_000_000,
 		}),
+		upgrade_key: Some(UpgradeKeyConfig {
+			key: endowed_accounts[0].clone(),
+		}),
 	}
 }
 
@@ -139,7 +143,7 @@ pub fn staging_testnet_config() -> ChainSpec {
 	)
 }
 
-fn testnet_genesis(initial_authorities: Vec<AuthorityId>) -> GenesisConfig {
+fn testnet_genesis(initial_authorities: Vec<AuthorityId>, upgrade_key: AccountId) -> GenesisConfig {
 	let endowed_accounts = vec![
 		ed25519::Pair::from_seed(b"Alice                           ").public().0.into(),
 		ed25519::Pair::from_seed(b"Bob                             ").public().0.into(),
@@ -220,13 +224,18 @@ fn testnet_genesis(initial_authorities: Vec<AuthorityId>) -> GenesisConfig {
 			max_depth: 1024,
 			block_gas_limit: 10_000_000,
 		}),
+		upgrade_key: Some(UpgradeKeyConfig {
+			key: upgrade_key,
+		}),
 	}
 }
 
 fn development_config_genesis() -> GenesisConfig {
 	testnet_genesis(vec![
 		ed25519::Pair::from_seed(b"Alice                           ").public().into(),
-	])
+	],
+		ed25519::Pair::from_seed(b"Alice                           ").public().0.into()
+	)
 }
 
 /// Development config (single validator Alice)
@@ -238,7 +247,9 @@ fn local_testnet_genesis() -> GenesisConfig {
 	testnet_genesis(vec![
 		ed25519::Pair::from_seed(b"Alice                           ").public().into(),
 		ed25519::Pair::from_seed(b"Bob                             ").public().into(),
-	])
+	],
+		ed25519::Pair::from_seed(b"Alice                           ").public().0.into()
+	)
 }
 
 /// Local testnet config (multivalidator Alice + Bob)

substrate/node/cli/src/lib.rs

@@ -30,9 +30,9 @@ extern crate hex_literal;
 #[cfg(test)]
 extern crate substrate_service_test as service_test;
 extern crate substrate_transaction_pool as transaction_pool;
+#[macro_use]
 extern crate substrate_network as network;
-extern crate node_network;
-extern crate sr_primitives as runtime_primitives;
+extern crate substrate_consensus_aura as consensus;
 extern crate node_primitives;
 #[macro_use]
 extern crate substrate_service;

substrate/node/cli/src/service.rs

@@ -22,38 +22,19 @@ use std::sync::Arc;
 use transaction_pool::{self, txpool::{Pool as TransactionPool}};
 use node_primitives::Block;
 use node_runtime::GenesisConfig;
-use node_network::Protocol as NodeProtocol;
 use substrate_service::{
 	FactoryFullConfiguration, LightComponents, FullComponents, FullBackend,
-	LightBackend, FullExecutor, LightExecutor
+	FullClient, LightClient, LightBackend, FullExecutor, LightExecutor,
+	Roles, TaskExecutor,
 };
-use network::import_queue::{BasicQueue, BlockOrigin, ImportBlock, Verifier};
-use runtime_primitives::{traits::Block as BlockT};
-use primitives::AuthorityId;
 use node_executor;
+use consensus::{import_queue, start_aura, Config as AuraConfig, AuraImportQueue};
 
-// TODO: Remove me, when we have a functional consensus.
-/// A verifier that doesn't actually do any checks
-pub struct NoneVerifier;
-/// This Verifiyer accepts all data as valid
-impl<B: BlockT> Verifier<B> for NoneVerifier {
-	fn verify(
-		&self,
-		origin: BlockOrigin,
-		header: B::Header,
-		justification: Vec<u8>,
-		body: Option<Vec<B::Extrinsic>>
-	) -> Result<(ImportBlock<B>, Option<Vec<AuthorityId>>), String> {
-		Ok((ImportBlock {
-			origin,
-			header,
-			body,
-			finalized: true,
-			external_justification: justification,
-			internal_justification: vec![],
-			auxiliary: Vec::new(),
-		}, None))
-	}
+const AURA_SLOT_DURATION: u64 = 6;
+
+construct_simple_protocol! {
+	/// Demo protocol attachment for substrate.
+	pub struct NodeProtocol where Block = Block { }
 }
 
 construct_simple_service!(Service);
@@ -70,15 +51,48 @@ construct_service_factory! {
 		Genesis = GenesisConfig,
 		Configuration = (),
 		FullService = Service<FullComponents<Self>>
-			{ |config, executor| Service::<FullComponents<Factory>>::new(config, executor) },
+			{ |config: FactoryFullConfiguration<Self>, executor: TaskExecutor| {
+				let is_auth = config.roles == Roles::AUTHORITY;
+				Service::<FullComponents<Factory>>::new(config, executor.clone()).map(move |service|{
+					if is_auth {
+						if let Ok(Some(Ok(key))) = service.keystore().contents()
+							.map(|keys| keys.get(0).map(|k| service.keystore().load(k, "")))
+						{
+							info!("Using authority key {}", key.public());
+							let task = start_aura(
+								AuraConfig {
+									local_key:  Some(Arc::new(key)),
+									slot_duration: AURA_SLOT_DURATION,
+								},
+								service.client(),
+								service.proposer(),
+								service.network(),
+							);
+
+							executor.spawn(task);
+						}
+					}
+
+					service
+				})
+			}
+		},
 		LightService = Service<LightComponents<Self>>
 			{ |config, executor| Service::<LightComponents<Factory>>::new(config, executor) },
-		ImportQueue = BasicQueue<Block, NoneVerifier>
-			{ |_, _| Ok(BasicQueue::new(Arc::new(NoneVerifier {}))) }
-			{ |_, _| Ok(BasicQueue::new(Arc::new(NoneVerifier {}))) },
+		FullImportQueue = AuraImportQueue<Self::Block, FullClient<Self>>
+			{ |config, client| Ok(import_queue(AuraConfig {
+						local_key: None,
+						slot_duration: 5
+					}, client)) },
+		LightImportQueue = AuraImportQueue<Self::Block, LightClient<Self>>
+			{ |config, client| Ok(import_queue(AuraConfig {
+						local_key: None,
+						slot_duration: 5
+					}, client)) },
 	}
 }
 
+
 #[cfg(test)]
 mod tests {
 	#[cfg(feature = "rhd")]