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/consensus/common/src/lib.rs

@@ -15,22 +15,118 @@
 // along with Substrate Consensus Common.  If not, see <http://www.gnu.org/licenses/>.
 
 // tag::description[]
-//! Tracks offline validators.
+//! Consensus basics and common features
 // end::description[]
 
+// This provides "unused" building blocks to other crates
 #![allow(dead_code)]
 
-#![cfg(feature="rhd")]
+// our error-chain could potentially blow up otherwise
+#![recursion_limit="128"]
 
 extern crate substrate_primitives as primitives;
+extern crate futures;
+extern crate sr_version as runtime_version;
+extern crate sr_primitives as runtime_primitives;
+extern crate tokio;
 
-use primitives::{generic::BlockId, Justification};
-use primitives::traits::{Block, Header};
+extern crate parity_codec as codec;
+#[macro_use]
+extern crate parity_codec_derive;
 
-/// Block import trait.
-pub trait BlockImport<B: Block> {
-	/// Import a block alongside its corresponding justification.
-	fn import_block(&self, block: B, justification: Justification, authorities: &[AuthorityId]) -> bool;
+#[macro_use]
+extern crate error_chain;
+
+use std::sync::Arc;
+
+use primitives::{ed25519, AuthorityId};
+use runtime_primitives::generic::BlockId;
+use runtime_primitives::traits::Block;
+use futures::prelude::*;
+
+pub mod offline_tracker;
+pub mod error;
+mod block_import;
+pub mod evaluation;
+
+// block size limit.
+const MAX_TRANSACTIONS_SIZE: usize = 4 * 1024 * 1024;
+
+pub use self::error::{Error, ErrorKind};
+pub use block_import::{BlockImport, ImportBlock, BlockOrigin, ImportResult};
+
+/// Trait for getting the authorities at a given block.
+pub trait Authorities<B: Block> {
+	type Error: ::std::error::Error + Send + 'static;	/// Get the authorities at the given block.
+	fn authorities(&self, at: &BlockId<B>) -> Result<Vec<AuthorityId>, Self::Error>;
 }
 
-pub mod offline_tracker;
+/// Environment producer for a Consensus instance. Creates proposer instance and communication streams.
+pub trait Environment<B: Block> {
+	/// The proposer type this creates.
+	type Proposer: Proposer<B>;
+	/// Error which can occur upon creation.
+	type Error: From<Error>;
+
+	/// Initialize the proposal logic on top of a specific header. Provide
+	/// the authorities at that header, and a local key to sign any additional
+	/// consensus messages with as well.
+	fn init(&self, parent_header: &B::Header, authorities: &[AuthorityId], sign_with: Arc<ed25519::Pair>)
+		-> Result<Self::Proposer, Self::Error>;
+}
+
+/// Logic for a proposer.
+///
+/// This will encapsulate creation and evaluation of proposals at a specific
+/// block.
+pub trait Proposer<B: Block> {
+	/// Error type which can occur when proposing or evaluating.
+	type Error: From<Error> + ::std::fmt::Debug + 'static;
+	/// Future that resolves to a committed proposal.
+	type Create: IntoFuture<Item=B,Error=Self::Error>;
+	/// Create a proposal.
+	fn propose(&self) -> Self::Create;
+}
+
+/// Inherent data to include in a block.
+#[derive(Encode, Decode)]
+pub struct InherentData {
+	/// Current timestamp.
+	pub timestamp: u64,
+	/// Indices of offline validators.
+	pub offline_indices: Vec<u32>,
+}
+
+impl InherentData {
+	/// Create a new `InherentData` instance.
+	pub fn new(timestamp: u64, offline_indices: Vec<u32>) -> Self {
+		Self {
+			timestamp,
+			offline_indices
+		}
+	}
+}
+
+/// An oracle for when major synchronization work is being undertaken.
+///
+/// Generally, consensus authoring work isn't undertaken while well behind
+/// the head of the chain.
+pub trait SyncOracle {
+	/// Whether the synchronization service is undergoing major sync.
+	/// Returns true if so.
+	fn is_major_syncing(&self) -> bool;
+}
+
+/// A synchronization oracle for when there is no network.
+#[derive(Clone, Copy, Debug)]
+pub struct NoNetwork;
+
+impl SyncOracle for NoNetwork {
+	fn is_major_syncing(&self) -> bool { false }
+}
+
+impl<T: SyncOracle> SyncOracle for Arc<T> {
+	fn is_major_syncing(&self) -> bool {
+		T::is_major_syncing(&*self)
+	}
+}