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/core/service/src/chain_ops.rs

@@ -20,11 +20,12 @@ use std::{self, io::{Read, Write}};
 use futures::Future;
 use serde_json;
 
-use client::BlockOrigin;
 use runtime_primitives::generic::{SignedBlock, BlockId};
 use runtime_primitives::traits::{As, Block, Header};
 use network::import_queue::{ImportQueue, BlockData};
 use network::message;
+
+use consensus_common::BlockOrigin;
 use components::{self, Components, ServiceFactory, FactoryFullConfiguration, FactoryBlockNumber, RuntimeGenesis};
 use new_client;
 use codec::{Decode, Encode};

substrate/core/service/src/components.rs

@@ -25,7 +25,7 @@ use chain_spec::ChainSpec;
 use client_db;
 use client::{self, Client};
 use {error, Service};
-use network::{self, OnDemand};
+use network::{self, OnDemand, import_queue::ImportQueue};
 use substrate_executor::{NativeExecutor, NativeExecutionDispatch};
 use transaction_pool::txpool::{self, Options as TransactionPoolOptions, Pool as TransactionPool};
 use runtime_primitives::{traits::Block as BlockT, traits::Header as HeaderT, BuildStorage};
@@ -136,8 +136,10 @@ pub trait ServiceFactory: 'static + Sized {
 	type FullService: Deref<Target = Service<FullComponents<Self>>> + Send + Sync + 'static;
 	/// Extended light service type.
 	type LightService: Deref<Target = Service<LightComponents<Self>>> + Send + Sync + 'static;
-	/// ImportQueue
-	type ImportQueue: network::import_queue::ImportQueue<Self::Block> + 'static;
+	/// ImportQueue for full client
+	type FullImportQueue: network::import_queue::ImportQueue<Self::Block> + 'static;
+	/// ImportQueue for light clients
+	type LightImportQueue: network::import_queue::ImportQueue<Self::Block> + 'static;
 
 	//TODO: replace these with a constructor trait. that TransactionPool implements.
 	/// Extrinsic pool constructor for the full client.
@@ -162,7 +164,7 @@ pub trait ServiceFactory: 'static + Sized {
 	fn build_full_import_queue(
 		config: &FactoryFullConfiguration<Self>,
 		_client: Arc<FullClient<Self>>
-	) -> Result<Self::ImportQueue, error::Error> {
+	) -> Result<Self::FullImportQueue, error::Error> {
 		if let Some(name) = config.chain_spec.consensus_engine() {
 			match name {
 				_ => Err(format!("Chain Specification defines unknown consensus engine '{}'", name).into())
@@ -177,7 +179,7 @@ pub trait ServiceFactory: 'static + Sized {
 	fn build_light_import_queue(
 		config: &FactoryFullConfiguration<Self>,
 		_client: Arc<LightClient<Self>>
-	) -> Result<Self::ImportQueue, error::Error> {
+	) -> Result<Self::LightImportQueue, error::Error> {
 		if let Some(name) = config.chain_spec.consensus_engine() {
 			match name {
 				_ => Err(format!("Chain Specification defines unknown consensus engine '{}'", name).into())
@@ -196,13 +198,16 @@ pub trait Components: 'static {
 	/// Client backend.
 	type Backend: 'static + client::backend::Backend<FactoryBlock<Self::Factory>, Blake2Hasher>;
 	/// Client executor.
-	type Executor: 'static + client::CallExecutor<FactoryBlock<Self::Factory>, Blake2Hasher> + Send + Sync;
+	type Executor: 'static + client::CallExecutor<FactoryBlock<Self::Factory>, Blake2Hasher> + Send + Sync + Clone;
 	/// Extrinsic pool type.
 	type TransactionPoolApi: 'static + txpool::ChainApi<
 		Hash = <<Self::Factory as ServiceFactory>::Block as BlockT>::Hash,
 		Block = FactoryBlock<Self::Factory>
 	>;
 
+	/// Our Import Queue
+	type ImportQueue: ImportQueue<FactoryBlock<Self::Factory>> + 'static;
+
 	/// Create client.
 	fn build_client(
 		config: &FactoryFullConfiguration<Self::Factory>,
@@ -221,7 +226,7 @@ pub trait Components: 'static {
 	fn build_import_queue(
 		config: &FactoryFullConfiguration<Self::Factory>,
 		client: Arc<ComponentClient<Self>>
-	) -> Result<<Self::Factory as ServiceFactory>::ImportQueue, error::Error>;
+	) -> Result<Self::ImportQueue, error::Error>;
 }
 
 /// A struct that implement `Components` for the full client.
@@ -234,6 +239,7 @@ impl<Factory: ServiceFactory> Components for FullComponents<Factory> {
 	type Executor = FullExecutor<Factory>;
 	type Backend = FullBackend<Factory>;
 	type TransactionPoolApi = <Factory as ServiceFactory>::FullTransactionPoolApi;
+	type ImportQueue = Factory::FullImportQueue;
 
 	fn build_client(
 		config: &FactoryFullConfiguration<Factory>,
@@ -267,7 +273,7 @@ impl<Factory: ServiceFactory> Components for FullComponents<Factory> {
 	fn build_import_queue(
 		config: &FactoryFullConfiguration<Self::Factory>,
 		client: Arc<ComponentClient<Self>>
-	) -> Result<<Self::Factory as ServiceFactory>::ImportQueue, error::Error> {
+	) -> Result<Self::ImportQueue, error::Error> {
 		Factory::build_full_import_queue(config, client)
 	}
 }
@@ -282,6 +288,7 @@ impl<Factory: ServiceFactory> Components for LightComponents<Factory> {
 	type Executor = LightExecutor<Factory>;
 	type Backend = LightBackend<Factory>;
 	type TransactionPoolApi = <Factory as ServiceFactory>::LightTransactionPoolApi;
+	type ImportQueue = <Factory as ServiceFactory>::LightImportQueue;
 
 	fn build_client(
 		config: &FactoryFullConfiguration<Factory>,
@@ -316,7 +323,7 @@ impl<Factory: ServiceFactory> Components for LightComponents<Factory> {
 	fn build_import_queue(
 		config: &FactoryFullConfiguration<Self::Factory>,
 		client: Arc<ComponentClient<Self>>
-	) -> Result<<Self::Factory as ServiceFactory>::ImportQueue, error::Error> {
+	) -> Result<Self::ImportQueue, error::Error> {
 		Factory::build_light_import_queue(config, client)
 	}
 }

substrate/core/service/src/consensus.rs

@@ -0,0 +1,263 @@
+// Copyright 2018 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! provide consensus service to substrate.
+
+// FIXME: move this into substrate-consensus-common - https://github.com/paritytech/substrate/issues/1021
+
+use std::sync::Arc;
+use std::time::{self, Duration, Instant};
+use std;
+
+use client::{self, error, Client as SubstrateClient, CallExecutor};
+use client::runtime_api::{Core, BlockBuilder as BlockBuilderAPI, id::BLOCK_BUILDER};
+use codec::{Decode, Encode};
+use consensus_common::{self, InherentData, evaluation, offline_tracker::OfflineTracker};
+use primitives::{AuthorityId, ed25519, Blake2Hasher};
+use runtime_primitives::traits::{Block as BlockT, Hash as HashT, Header as HeaderT};
+use runtime_primitives::generic::BlockId;
+use transaction_pool::txpool::{self, Pool as TransactionPool};
+
+use parking_lot::RwLock;
+
+/// Shared offline validator tracker.
+pub type SharedOfflineTracker = Arc<RwLock<OfflineTracker>>;
+type Timestamp = u64;
+
+// block size limit.
+const MAX_TRANSACTIONS_SIZE: usize = 4 * 1024 * 1024;
+
+/// Build new blocks.
+pub trait BlockBuilder<Block: BlockT> {
+	/// Push an extrinsic onto the block. Fails if the extrinsic is invalid.
+	fn push_extrinsic(&mut self, extrinsic: <Block as BlockT>::Extrinsic) -> Result<(), error::Error>;
+}
+
+/// Local client abstraction for the consensus.
+pub trait AuthoringApi:
+	Send
+	+ Sync
+	+ BlockBuilderAPI<<Self as AuthoringApi>::Block, Error=<Self as AuthoringApi>::Error>
+	+ Core<<Self as AuthoringApi>::Block, AuthorityId, Error=<Self as AuthoringApi>::Error>
+{
+	/// The block used for this API type.
+	type Block: BlockT;
+	/// The error used by this API type.
+	type Error: std::error::Error;
+
+	/// Build a block on top of the given, with inherent extrinsics pre-pushed.
+	fn build_block<F: FnMut(&mut BlockBuilder<Self::Block>) -> ()>(
+		&self,
+		at: &BlockId<Self::Block>,
+		inherent_data: InherentData,
+		build_ctx: F,
+	) -> Result<Self::Block, error::Error>;
+}
+
+impl<'a, B, E, Block> BlockBuilder<Block> for client::block_builder::BlockBuilder<'a, B, E, Block, Blake2Hasher> where
+	B: client::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
+	E: CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone + 'static,
+	Block: BlockT
+{
+	fn push_extrinsic(&mut self, extrinsic: <Block as BlockT>::Extrinsic) -> Result<(), error::Error> {
+		client::block_builder::BlockBuilder::push(self, extrinsic).map_err(Into::into)
+	}
+}
+
+impl<'a, B, E, Block> AuthoringApi for SubstrateClient<B, E, Block> where
+	B: client::backend::Backend<Block, Blake2Hasher> + Send + Sync + 'static,
+	E: CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone + 'static,
+	Block: BlockT,
+{
+	type Block = Block;
+	type Error = client::error::Error;
+
+	fn build_block<F: FnMut(&mut BlockBuilder<Self::Block>) -> ()>(
+		&self,
+		at: &BlockId<Self::Block>,
+		inherent_data: InherentData,
+		mut build_ctx: F,
+	) -> Result<Self::Block, error::Error> {
+		let runtime_version = self.runtime_version_at(at)?;
+
+		let mut block_builder = self.new_block_at(at)?;
+		if runtime_version.has_api(BLOCK_BUILDER, 1) {
+			self.inherent_extrinsics(at, &inherent_data)?
+				.into_iter().try_for_each(|i| block_builder.push(i))?;
+		}
+
+		build_ctx(&mut block_builder);
+
+		block_builder.bake().map_err(Into::into)
+	}
+}
+
+/// Proposer factory.
+pub struct ProposerFactory<C, A> where
+	C: AuthoringApi,
+	A: txpool::ChainApi,
+{
+	/// The client instance.
+	pub client: Arc<C>,
+	/// The transaction pool.
+	pub transaction_pool: Arc<TransactionPool<A>>,
+	/// Offline-tracker.
+	pub offline: SharedOfflineTracker,
+	/// Force delay in evaluation this long.
+	pub force_delay: Timestamp,
+}
+
+impl<C, A> consensus_common::Environment<<C as AuthoringApi>::Block> for ProposerFactory<C, A> where
+	C: AuthoringApi,
+	A: txpool::ChainApi<Block=<C as AuthoringApi>::Block>,
+	client::error::Error: From<<C as AuthoringApi>::Error>
+{
+	type Proposer = Proposer<C, A>;
+	type Error = error::Error;
+
+	fn init(
+		&self,
+		parent_header: &<<C as AuthoringApi>::Block as BlockT>::Header,
+		_: &[AuthorityId],
+		_: Arc<ed25519::Pair>,
+	) -> Result<Self::Proposer, error::Error> {
+		let parent_hash = parent_header.hash();
+
+		let id = BlockId::hash(parent_hash);
+
+		let authorities: Vec<AuthorityId> = self.client.authorities(&id)?;
+		self.offline.write().note_new_block(&authorities[..]);
+
+		info!("Starting consensus session on top of parent {:?}", parent_hash);
+
+		let now = Instant::now();
+		let proposer = Proposer {
+			client: self.client.clone(),
+			start: now,
+			parent_hash,
+			parent_id: id,
+			parent_number: *parent_header.number(),
+			transaction_pool: self.transaction_pool.clone(),
+			offline: self.offline.clone(),
+			authorities,
+			minimum_timestamp: current_timestamp() + self.force_delay,
+		};
+
+		Ok(proposer)
+	}
+}
+
+/// The proposer logic.
+pub struct Proposer<C: AuthoringApi, A: txpool::ChainApi> {
+	client: Arc<C>,
+	start: Instant,
+	parent_hash: <<C as AuthoringApi>::Block as BlockT>::Hash,
+	parent_id: BlockId<<C as AuthoringApi>::Block>,
+	parent_number: <<<C as AuthoringApi>::Block as BlockT>::Header as HeaderT>::Number,
+	transaction_pool: Arc<TransactionPool<A>>,
+	offline: SharedOfflineTracker,
+	authorities: Vec<AuthorityId>,
+	minimum_timestamp: u64,
+}
+
+impl<C, A> consensus_common::Proposer<<C as AuthoringApi>::Block> for Proposer<C, A> where
+	C: AuthoringApi,
+	A: txpool::ChainApi<Block=<C as AuthoringApi>::Block>,
+	client::error::Error: From<<C as AuthoringApi>::Error>
+{
+	type Create = Result<<C as AuthoringApi>::Block, error::Error>;
+	type Error = error::Error;
+
+	fn propose(&self) -> Result<<C as AuthoringApi>::Block, error::Error> {
+		use runtime_primitives::traits::BlakeTwo256;
+
+		const MAX_VOTE_OFFLINE_SECONDS: Duration = Duration::from_secs(60);
+
+		let timestamp = ::std::cmp::max(self.minimum_timestamp, current_timestamp());
+
+		let elapsed_since_start = self.start.elapsed();
+		let offline_indices = if elapsed_since_start > MAX_VOTE_OFFLINE_SECONDS {
+			Vec::new()
+		} else {
+			self.offline.read().reports(&self.authorities[..])
+		};
+
+		if !offline_indices.is_empty() {
+			info!("Submitting offline authorities {:?} for slash-vote",
+				offline_indices.iter().map(|&i| self.authorities[i as usize]).collect::<Vec<_>>(),
+			)
+		}
+
+		let inherent_data = InherentData {
+			timestamp,
+			offline_indices,
+		};
+
+		let block = self.client.build_block(
+			&self.parent_id,
+			inherent_data,
+			|block_builder| {
+				let mut unqueue_invalid = Vec::new();
+				let mut pending_size = 0;
+				let pending_iterator = self.transaction_pool.ready();
+
+				for pending in pending_iterator {
+					// TODO [ToDr] Probably get rid of it, and validate in runtime.
+					let encoded_size = pending.data.encode().len();
+					if pending_size + encoded_size >= MAX_TRANSACTIONS_SIZE { break }
+
+					match block_builder.push_extrinsic(pending.data.clone()) {
+						Ok(()) => {
+							pending_size += encoded_size;
+						}
+						Err(e) => {
+							trace!(target: "transaction-pool", "Invalid transaction: {}", e);
+							unqueue_invalid.push(pending.hash.clone());
+						}
+					}
+				}
+
+				self.transaction_pool.remove_invalid(&unqueue_invalid);
+			})?;
+
+		info!("Proposing block [number: {}; hash: {}; parent_hash: {}; extrinsics: [{}]]",
+			  block.header().number(),
+			  <<C as AuthoringApi>::Block as BlockT>::Hash::from(block.header().hash()),
+			  block.header().parent_hash(),
+			  block.extrinsics().iter()
+			  .map(|xt| format!("{}", BlakeTwo256::hash_of(xt)))
+			  .collect::<Vec<_>>()
+			  .join(", ")
+			 );
+
+		let substrate_block = Decode::decode(&mut block.encode().as_slice())
+			.expect("blocks are defined to serialize to substrate blocks correctly; qed");
+
+		assert!(evaluation::evaluate_initial(
+			&substrate_block,
+			&self.parent_hash,
+			self.parent_number,
+		).is_ok());
+
+		Ok(substrate_block)
+	}
+}
+
+fn current_timestamp() -> Timestamp {
+	time::SystemTime::now().duration_since(time::UNIX_EPOCH)
+		.expect("now always later than unix epoch; qed")
+		.as_secs()
+}

substrate/core/service/src/lib.rs

@@ -29,6 +29,7 @@ extern crate parking_lot;
 extern crate substrate_keystore as keystore;
 extern crate substrate_primitives as primitives;
 extern crate sr_primitives as runtime_primitives;
+extern crate substrate_consensus_common as consensus_common;
 extern crate substrate_network as network;
 extern crate substrate_executor;
 extern crate substrate_client as client;
@@ -56,6 +57,7 @@ mod error;
 mod chain_spec;
 pub mod config;
 pub mod chain_ops;
+pub mod consensus;
 
 use std::io;
 use std::net::SocketAddr;
@@ -63,7 +65,7 @@ use std::collections::HashMap;
 #[doc(hidden)]
 pub use std::{ops::Deref, result::Result, sync::Arc};
 use futures::prelude::*;
-use parking_lot::Mutex;
+use parking_lot::{Mutex, RwLock};
 use keystore::Store as Keystore;
 use client::BlockchainEvents;
 use runtime_primitives::traits::{Header, As};
@@ -80,6 +82,8 @@ pub use chain_spec::ChainSpec;
 pub use transaction_pool::txpool::{self, Pool as TransactionPool, Options as TransactionPoolOptions, ChainApi, IntoPoolError};
 pub use client::ExecutionStrategy;
 
+use consensus_common::offline_tracker::OfflineTracker;
+pub use consensus::ProposerFactory;
 pub use components::{ServiceFactory, FullBackend, FullExecutor, LightBackend,
 	LightExecutor, Components, PoolApi, ComponentClient,
 	ComponentBlock, FullClient, LightClient, FullComponents, LightComponents,
@@ -98,6 +102,7 @@ pub struct Service<Components: components::Components> {
 	keystore: Keystore,
 	exit: ::exit_future::Exit,
 	signal: Option<Signal>,
+	proposer: Arc<ProposerFactory<ComponentClient<Components>, Components::TransactionPoolApi>>,
 	_rpc_http: Option<rpc::HttpServer>,
 	_rpc_ws: Option<Mutex<rpc::WsServer>>, // WsServer is not `Sync`, but the service needs to be.
 	_telemetry: Option<tel::Telemetry>,
@@ -118,6 +123,7 @@ pub fn new_client<Factory: components::ServiceFactory>(config: &FactoryFullConfi
 impl<Components> Service<Components>
 	where
 		Components: components::Components,
+		<Components as components::Components>::Executor: std::clone::Clone,
 		txpool::ExHash<Components::TransactionPoolApi>: serde::de::DeserializeOwned + serde::Serialize,
 		txpool::ExtrinsicFor<Components::TransactionPoolApi>: serde::de::DeserializeOwned + serde::Serialize,
 {
@@ -254,6 +260,13 @@ impl<Components> Service<Components>
 			)
 		};
 
+		let proposer = Arc::new(ProposerFactory {
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			offline: Arc::new(RwLock::new(OfflineTracker::new())),
+			force_delay: 0 // FIXME: allow this to be configured
+		});
+
 		// Telemetry
 		let telemetry = match config.telemetry_url {
 			Some(url) => {
@@ -287,6 +300,7 @@ impl<Components> Service<Components>
 			transaction_pool: transaction_pool,
 			signal: Some(signal),
 			keystore: keystore,
+			proposer,
 			exit,
 			_rpc_http: rpc_http,
 			_rpc_ws: rpc_ws.map(Mutex::new),
@@ -303,6 +317,13 @@ impl<Components> Service<Components> where
 		self.client.clone()
 	}
 
+	/// Get shared proposer instance
+	pub fn proposer(&self)
+		-> Arc<ProposerFactory<ComponentClient<Components>, Components::TransactionPoolApi>>
+	{
+		self.proposer.clone()
+	}
+
 	/// Get shared network instance.
 	pub fn network(&self) -> Arc<components::NetworkService<Components::Factory>> {
 		self.network.as_ref().expect("self.network always Some").clone()
@@ -324,6 +345,7 @@ impl<Components> Service<Components> where
 	}
 }
 
+
 impl<Components> Drop for Service<Components> where Components: components::Components {
 	fn drop(&mut self) {
 		debug!(target: "service", "Substrate service shutdown");
@@ -450,7 +472,7 @@ macro_rules! construct_simple_service {
 		$name: ident
 	) => {
 		pub struct $name<C: $crate::Components> {
-			inner: $crate::Service<C>,
+			inner: $crate::Arc<$crate::Service<C>>,
 		}
 
 		impl<C: $crate::Components> $name<C> {
@@ -460,7 +482,7 @@ macro_rules! construct_simple_service {
 			) -> $crate::Result<Self, $crate::Error> {
 				Ok(
 					Self {
-						inner: $crate::Service::new(config, executor)?
+						inner: $crate::Arc::new($crate::Service::new(config, executor)?)
 					}
 				)
 			}
@@ -525,8 +547,9 @@ macro_rules! construct_service_factory {
 			Configuration = $config:ty,
 			FullService = $full_service:ty { $( $full_service_init:tt )* },
 			LightService = $light_service:ty { $( $light_service_init:tt )* },
-			ImportQueue = $import_queue:ty
-				{ $( $full_import_queue_init:tt )* }
+			FullImportQueue = $full_import_queue:ty
+				{ $( $full_import_queue_init:tt )* },
+			LightImportQueue = $light_import_queue:ty
 				{ $( $light_import_queue_init:tt )* },
 		}
 	) => {
@@ -544,7 +567,8 @@ macro_rules! construct_service_factory {
 			type Configuration = $config;
 			type FullService = $full_service;
 			type LightService = $light_service;
-			type ImportQueue = $import_queue;
+			type FullImportQueue = $full_import_queue;
+			type LightImportQueue = $light_import_queue;
 
 			fn build_full_transaction_pool(
 				config: $crate::TransactionPoolOptions,
@@ -571,14 +595,14 @@ macro_rules! construct_service_factory {
 			fn build_full_import_queue(
 				config: &$crate::FactoryFullConfiguration<Self>,
 				client: $crate::Arc<$crate::FullClient<Self>>,
-			) -> $crate::Result<Self::ImportQueue, $crate::Error> {
+			) -> $crate::Result<Self::FullImportQueue, $crate::Error> {
 				( $( $full_import_queue_init )* ) (config, client)
 			}
 
 			fn build_light_import_queue(
 				config: &FactoryFullConfiguration<Self>,
 				client: Arc<$crate::LightClient<Self>>,
-			) -> Result<Self::ImportQueue, $crate::Error> {
+			) -> Result<Self::LightImportQueue, $crate::Error> {
 				( $( $light_import_queue_init )* ) (config, client)
 			}