allow bft primitives to compile on wasm

substrate/bft/Cargo.toml

@@ -12,3 +12,4 @@ substrate-state-machine = { path = "../state-machine" }
 ed25519 = { path = "../ed25519" }
 tokio-timer = "0.1.2"
 parking_lot = "0.4"
+error-chain = "0.11"

substrate/bft/src/error.rs

@@ -0,0 +1,57 @@
+// Copyright 2017 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/>.
+
+//! Error types in the BFT service.
+
+error_chain! {
+	errors {
+		/// Missing state at block with given Id.
+		StateUnavailable(b: ::client::BlockId) {
+			description("State missing at given block."),
+			display("State unavailable at block {:?}", b),
+		}
+
+		/// I/O terminated unexpectedly
+		IoTerminated {
+			description("I/O terminated unexpectedly."),
+			display("I/O terminated unexpectedly."),
+		}
+
+		/// Unable to schedule wakeup.
+		FaultyTimer {
+			description("Faulty timer: unable to schedule wakeup"),
+			display("Faulty timer: unable to schedule wakeup"),
+		}
+
+		/// Unable to propose a block.
+		CannotPropose {
+			description("Unable to create block proposal."),
+			display("Unable to create block proposal."),
+		}
+
+		/// Error dispatching the agreement future onto the executor.
+		Executor(e: ::futures::future::ExecuteErrorKind) {
+			description("Unable to dispatch agreement future"),
+			display("Unable to dispatch agreement future: {:?}", e),
+		}
+	}
+}
+
+impl From<::generic::InputStreamConcluded> for Error {
+	fn from(_: ::generic::InputStreamConcluded) -> Error {
+		ErrorKind::IoTerminated.into()
+	}
+}

substrate/bft/src/generic/mod.rs

@@ -23,9 +23,11 @@ use std::hash::Hash;
 
 use futures::{future, Future, Stream, Sink, Poll, Async, AsyncSink};
 
-use accumulator::State;
+use self::accumulator::State;
 
-pub use accumulator::{Accumulator, Justification, PrepareJustification, UncheckedJustification};
+pub use self::accumulator::{Accumulator, Justification, PrepareJustification, UncheckedJustification};
+
+mod accumulator;
 
 #[cfg(test)]
 mod tests;

substrate/bft/src/lib.rs

@@ -16,7 +16,7 @@
 
 //! BFT Agreement based on a rotating proposer in different rounds.
 
-mod accumulator;
+pub mod error;
 pub mod generic;
 
 extern crate substrate_codec as codec;
@@ -30,11 +30,14 @@ extern crate parking_lot;
 #[macro_use]
 extern crate futures;
 
+#[macro_use]
+extern crate error_chain;
+
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 
-use client::Client;
+use client::{BlockId, Client};
 use client::backend::Backend;
 use codec::Slicable;
 use ed25519::Signature;
@@ -43,12 +46,13 @@ use primitives::AuthorityId;
 use state_machine::CodeExecutor;
 
 use futures::{stream, task, Async, Sink, Future};
-use futures::future::{Executor, ExecuteErrorKind};
+use futures::future::Executor;
 use futures::sync::oneshot;
 use tokio_timer::Timer;
 use parking_lot::Mutex;
 
 pub use generic::InputStreamConcluded;
+pub use error::{Error, ErrorKind};
 
 /// Messages over the proposal.
 /// Each message carries an associated round number.
@@ -74,23 +78,6 @@ pub type Committed = generic::Committed<Block, HeaderHash, Signature>;
 /// Communication between BFT participants.
 pub type Communication = generic::Communication<Block, HeaderHash, AuthorityId, Signature>;
 
-/// Errors that can occur during agreement.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Error {
-	/// Io streams terminated.
-	IoTerminated,
-	/// Timer failed to fire.
-	FaultyTimer,
-	/// Unable to propose for some reason.
-	CannotPropose,
-}
-
-impl From<InputStreamConcluded> for Error {
-	fn from(_: InputStreamConcluded) -> Error {
-		Error::IoTerminated
-	}
-}
-
 /// Logic for a proposer.
 ///
 /// This will encapsulate creation and evaluation of proposals at a specific
@@ -115,6 +102,12 @@ pub trait BlockImport {
 	fn import_block(&self, block: Block, justification: Justification);
 }
 
+/// Trait for getting the authorities at a given block.
+pub trait Authorities {
+	/// Get the authorities at the given block.
+	fn authorities(&self, at: &BlockId) -> Result<Vec<AuthorityId>, Error>;
+}
+
 impl<B, E> BlockImport for Client<B, E>
 	where
 		B: Backend,
@@ -127,6 +120,17 @@ impl<B, E> BlockImport for Client<B, E>
 	}
 }
 
+impl<B, E> Authorities for Client<B, E>
+	where
+		B: Backend,
+		E: CodeExecutor,
+		client::error::Error: From<<B::State as state_machine::backend::Backend>::Error>
+{
+	fn authorities(&self, at: &BlockId) -> Result<Vec<AuthorityId>, Error> {
+		self.authorities_at(at).map_err(|_| ErrorKind::StateUnavailable(*at).into())
+	}
+}
+
 
 /// Instance of BFT agreement.
 struct BftInstance<P> {
@@ -213,7 +217,7 @@ impl<P: Proposer> generic::Context for BftInstance<P> {
 			.saturating_mul(self.round_timeout_multiplier);
 
 		Box::new(self.timer.sleep(Duration::from_secs(timeout))
-			.map_err(|_| Error::FaultyTimer))
+			.map_err(|_| ErrorKind::FaultyTimer.into()))
 	}
 }
 
@@ -295,7 +299,7 @@ impl Drop for AgreementHandle {
 /// The BftService kicks off the agreement process on top of any blocks it
 /// is notified of.
 pub struct BftService<P, E, I> {
-	import: Arc<I>,
+	client: Arc<I>,
 	executor: E,
 	live_agreements: Mutex<HashMap<HeaderHash, AgreementHandle>>,
 	timer: Timer,
@@ -308,21 +312,21 @@ impl<P, E, I> BftService<P, E, I>
 	where
 		P: Proposer,
 		E: Executor<BftFuture<P, I>>,
-		I: BlockImport,
+		I: BlockImport + Authorities,
 {
 	/// Signal that a valid block with the given header has been imported.
 	///
 	/// This will begin the consensus process to build a block on top of it.
 	/// If the executor fails to run the future, an error will be returned.
-	pub fn build_upon(&self, header: &Header) -> Result<(), ExecuteErrorKind> {
+	pub fn build_upon(&self, header: &Header) -> Result<(), Error> {
 		let parent_hash = header.parent_hash.clone();
 		let hash = header.hash();
 		let mut _preempted_consensus = None;
 
 		let proposer = P::init(header, self.key.clone());
 
 		// TODO: check key is one of the authorities.
-		let authorities = Vec::new();
+		let authorities = self.client.authorities(&BlockId::Hash(hash))?;
 		let n = authorities.len();
 		let max_faulty = n.saturating_sub(1) / 3;
 
@@ -350,8 +354,8 @@ impl<P, E, I> BftService<P, E, I>
 			inner: agreement,
 			cancel: cancel.clone(),
 			send_task: Some(tx),
-			import: self.import.clone(),
-		}).map_err(|e| e.kind())?;
+			import: self.client.clone(),
+		}).map_err(|e| e.kind()).map_err(ErrorKind::Executor)?;
 
 		{
 			let mut live = self.live_agreements.lock();

substrate/primitives/src/bft.rs

@@ -18,6 +18,7 @@
 
 use block::{Block, HeaderHash};
 use codec::{Slicable, Input};
+use rstd::vec::Vec;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "std", derive(Debug))]

substrate/primitives/src/block.rs

@@ -147,6 +147,7 @@ impl Header {
 	}
 
 	/// Get the blake2-256 hash of this header.
+	#[cfg(feature = "std")]
 	pub fn hash(&self) -> HeaderHash {
 		::hashing::blake2_256(Slicable::encode(self).as_slice()).into()
 	}