Phase 1 of repo reorg (#719)

* Remove unneeded script

* Rename Substrate Demo -> Substrate

* Rename demo -> node

* Build wasm from last rename.

* Merge ed25519 into substrate-primitives

* Minor tweak

* Rename substrate -> core

* Move substrate-runtime-support to core/runtime/support

* Rename/move substrate-runtime-version

* Move codec up a level

* Rename substrate-codec -> parity-codec

* Move environmental up a level

* Move pwasm-* up to top, ready for removal

* Remove requirement of s-r-support from s-r-primitives

* Move core/runtime/primitives into core/runtime-primitives

* Remove s-r-support dep from s-r-version

* Remove dep of s-r-support from bft

* Remove dep of s-r-support from node/consensus

* Sever all other core deps from s-r-support

* Forgot the no_std directive

* Rename non-SRML modules to sr-* to avoid match clashes

* Move runtime/* to srml/*

* Rename substrate-runtime-* -> srml-*

* Move srml to top-level

substrate/node/Cargo.toml

@@ -0,0 +1,18 @@
+[[bin]]
+name = "substrate"
+path = "src/main.rs"
+
+[package]
+name = "substrate"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+build = "build.rs"
+
+[dependencies]
+error-chain = "0.12"
+node-cli = { path = "cli" }
+futures = "0.1"
+ctrlc = { version = "3.0", features = ["termination"] }
+
+[build-dependencies]
+vergen = "0.1"

substrate/node/api/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "node-api"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+node-runtime = { path = "../runtime" }
+node-primitives = { path = "../primitives" }
+substrate-client = { path = "../../core/client" }
+substrate-primitives = { path = "../../core/primitives" }
+
+[dev-dependencies]
+substrate-keyring = { path = "../../core/keyring" }

substrate/node/api/src/lib.rs

@@ -0,0 +1,155 @@
+// 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/>.
+
+//! Strongly typed API for Substrate runtime.
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+extern crate node_primitives as primitives;
+extern crate node_runtime as runtime;
+extern crate substrate_client as client;
+extern crate substrate_primitives;
+
+pub use client::error::{Error, ErrorKind, Result};
+use runtime::Address;
+use client::backend::Backend;
+use client::block_builder::BlockBuilder as ClientBlockBuilder;
+use client::{Client, CallExecutor};
+use primitives::{
+	AccountId, Block, BlockId, Hash, Index, InherentData,
+	SessionKey, Timestamp, UncheckedExtrinsic,
+};
+use substrate_primitives::{Blake2Hasher, RlpCodec};
+
+/// Build new blocks.
+pub trait BlockBuilder {
+	/// Push an extrinsic onto the block. Fails if the extrinsic is invalid.
+	fn push_extrinsic(&mut self, extrinsic: UncheckedExtrinsic) -> Result<()>;
+
+	/// Bake the block with provided extrinsics.
+	fn bake(self) -> Result<Block>;
+}
+
+/// Trait encapsulating the node API.
+///
+/// All calls should fail when the exact runtime is unknown.
+pub trait Api {
+	/// The block builder for this API type.
+	type BlockBuilder: BlockBuilder;
+
+	/// Get session keys at a given block.
+	fn session_keys(&self, at: &BlockId) -> Result<Vec<SessionKey>>;
+
+	/// Get validators at a given block.
+	fn validators(&self, at: &BlockId) -> Result<Vec<AccountId>>;
+
+	/// Get the value of the randomness beacon at a given block.
+	fn random_seed(&self, at: &BlockId) -> Result<Hash>;
+
+	/// Get the timestamp registered at a block.
+	fn timestamp(&self, at: &BlockId) -> Result<Timestamp>;
+
+	/// Get the nonce (né index) of an account at a block.
+	fn index(&self, at: &BlockId, account: AccountId) -> Result<Index>;
+
+	/// Get the account id of an address at a block.
+	fn lookup(&self, at: &BlockId, address: Address) -> Result<Option<AccountId>>;
+
+	/// Evaluate a block. Returns true if the block is good, false if it is known to be bad,
+	/// and an error if we can't evaluate for some reason.
+	fn evaluate_block(&self, at: &BlockId, block: Block) -> Result<bool>;
+
+	/// Build a block on top of the given, with inherent extrinsics pre-pushed.
+	fn build_block(&self, at: &BlockId, inherent_data: InherentData) -> Result<Self::BlockBuilder>;
+
+	/// Attempt to produce the (encoded) inherent extrinsics for a block being built upon the given.
+	/// This may vary by runtime and will fail if a runtime doesn't follow the same API.
+	fn inherent_extrinsics(&self, at: &BlockId, inherent_data: InherentData) -> Result<Vec<UncheckedExtrinsic>>;
+}
+
+impl<B, E> BlockBuilder for ClientBlockBuilder<B, E, Block, Blake2Hasher, RlpCodec>
+where
+	B: Backend<Block, Blake2Hasher, RlpCodec>,
+	E: CallExecutor<Block, Blake2Hasher, RlpCodec>+ Clone,
+{
+	fn push_extrinsic(&mut self, extrinsic: UncheckedExtrinsic) -> Result<()> {
+		self.push(extrinsic).map_err(Into::into)
+	}
+
+	/// Bake the block with provided extrinsics.
+	fn bake(self) -> Result<Block> {
+		ClientBlockBuilder::bake(self).map_err(Into::into)
+	}
+}
+
+impl<B, E> Api for Client<B, E, Block>
+where
+	B: Backend<Block, Blake2Hasher, RlpCodec>,
+	E: CallExecutor<Block, Blake2Hasher, RlpCodec> + Clone,
+{
+	type BlockBuilder = ClientBlockBuilder<B, E, Block, Blake2Hasher, RlpCodec>;
+
+	fn session_keys(&self, at: &BlockId) -> Result<Vec<SessionKey>> {
+		Ok(self.authorities_at(at)?)
+	}
+
+	fn validators(&self, at: &BlockId) -> Result<Vec<AccountId>> {
+		self.call_api_at(at, "validators", &())
+	}
+
+	fn random_seed(&self, at: &BlockId) -> Result<Hash> {
+		self.call_api_at(at, "random_seed", &())
+	}
+
+	fn timestamp(&self, at: &BlockId) -> Result<Timestamp> {
+		self.call_api_at(at, "timestamp", &())
+	}
+
+	fn evaluate_block(&self, at: &BlockId, block: Block) -> Result<bool> {
+		let res: Result<()> = self.call_api_at(at, "execute_block", &block);
+		match res {
+			Ok(()) => Ok(true),
+			Err(err) => match err.kind() {
+				&client::error::ErrorKind::Execution(_) => Ok(false),
+				_ => Err(err)
+			}
+		}
+	}
+
+	fn index(&self, at: &BlockId, account: AccountId) -> Result<Index> {
+		self.call_api_at(at, "account_nonce", &account)
+	}
+
+	fn lookup(&self, at: &BlockId, address: Address) -> Result<Option<AccountId>> {
+		self.call_api_at(at, "lookup_address", &address)
+	}
+
+	fn build_block(&self, at: &BlockId, inherent_data: InherentData) -> Result<Self::BlockBuilder> {
+		let mut block_builder = self.new_block_at(at)?;
+		for inherent in self.inherent_extrinsics(at, inherent_data)? {
+			block_builder.push(inherent)?;
+		}
+
+		Ok(block_builder)
+	}
+
+	fn inherent_extrinsics(&self, at: &BlockId, inherent_data: InherentData) -> Result<Vec<UncheckedExtrinsic>> {
+		let runtime_version = self.runtime_version_at(at)?;
+		self.call_api_at(at, "inherent_extrinsics", &(inherent_data, runtime_version.spec_version))
+	}
+}
+

substrate/node/build.rs

@@ -0,0 +1,24 @@
+// Copyright 2015-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/>.
+
+extern crate vergen;
+
+const ERROR_MSG: &'static str = "Failed to generate metadata files";
+
+fn main() {
+	vergen::vergen(vergen::SHORT_SHA).expect(ERROR_MSG);
+	println!("cargo:rerun-if-changed=../../.git/HEAD");
+}

substrate/node/cli/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "node-cli"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node implementation in Rust."
+
+[dependencies]
+log = "0.3"
+tokio = "0.1.7"
+exit-future = "0.1"
+substrate-cli = { path = "../../core/cli" }
+node-service = { path = "../service" }

substrate/node/cli/src/cli.yml

@@ -0,0 +1,12 @@
+name: substrate-node
+author: "Parity Team <admin@parity.io>"
+about: Substrate Node Rust Implementation
+args:
+  - log:
+      short: l
+      value_name: LOG_PATTERN
+      help: Sets a custom logging
+      takes_value: true
+subcommands:
+  - validator:
+      about: Run validator node

substrate/node/cli/src/error.rs

@@ -0,0 +1,29 @@
+// 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/>.
+
+//! Initialization errors.
+
+use client;
+
+error_chain! {
+	foreign_links {
+		Io(::std::io::Error) #[doc="IO error"];
+		Cli(::clap::Error) #[doc="CLI error"];
+	}
+	links {
+		Client(client::error::Error, client::error::ErrorKind) #[doc="Client error"];
+	}
+}

substrate/node/cli/src/lib.rs

@@ -0,0 +1,122 @@
+// 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/>.
+
+//! Substrate CLI library.
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+extern crate tokio;
+
+extern crate substrate_cli as cli;
+extern crate node_service as service;
+extern crate exit_future;
+
+#[macro_use]
+extern crate log;
+
+pub use cli::error;
+
+use tokio::runtime::Runtime;
+pub use service::{Components as ServiceComponents, Service, CustomConfiguration};
+pub use cli::{VersionInfo, IntoExit};
+
+/// The chain specification option.
+#[derive(Clone, Debug)]
+pub enum ChainSpec {
+	/// Whatever the current runtime is, with just Alice as an auth.
+	Development,
+	/// Whatever the current runtime is, with simple Alice/Bob auths.
+	LocalTestnet,
+	/// The PoC-1 & PoC-2 era testnet.
+	Testnet,
+	/// Whatever the current runtime is with the "global testnet" defaults.
+	StagingTestnet,
+}
+
+/// Get a chain config from a spec setting.
+impl ChainSpec {
+	pub(crate) fn load(self) -> Result<service::ChainSpec, String> {
+		Ok(match self {
+			ChainSpec::Testnet => service::chain_spec::testnet_config()?,
+			ChainSpec::Development => service::chain_spec::development_config(),
+			ChainSpec::LocalTestnet => service::chain_spec::local_testnet_config(),
+			ChainSpec::StagingTestnet => service::chain_spec::staging_testnet_config(),
+		})
+	}
+
+	pub(crate) fn from(s: &str) -> Option<Self> {
+		match s {
+			"dev" => Some(ChainSpec::Development),
+			"local" => Some(ChainSpec::LocalTestnet),
+			"" | "test" => Some(ChainSpec::Testnet),
+			"staging" => Some(ChainSpec::StagingTestnet),
+			_ => None,
+		}
+	}
+}
+
+fn load_spec(id: &str) -> Result<Option<service::ChainSpec>, String> {
+	Ok(match ChainSpec::from(id) {
+		Some(spec) => Some(spec.load()?),
+		None => None,
+	})
+}
+
+/// Parse command line arguments into service configuration.
+pub fn run<I, T, E>(args: I, exit: E, version: cli::VersionInfo) -> error::Result<()> where
+	I: IntoIterator<Item = T>,
+	T: Into<std::ffi::OsString> + Clone,
+	E: IntoExit,
+{
+	match cli::prepare_execution::<service::Factory, _, _, _, _>(args, exit, version, load_spec, "substrate-node")? {
+		cli::Action::ExecutedInternally => (),
+		cli::Action::RunService((config, exit)) => {
+			info!("Parity ·:· Substrate");
+			info!("  version {}", config.full_version());
+			info!("  by Parity Technologies, 2017, 2018");
+			info!("Chain specification: {}", config.chain_spec.name());
+			info!("Node name: {}", config.name);
+			info!("Roles: {:?}", config.roles);
+			let mut runtime = Runtime::new()?;
+			let executor = runtime.executor();
+			match config.roles == service::Roles::LIGHT {
+				true => run_until_exit(&mut runtime, service::new_light(config, executor)?, exit)?,
+				false => run_until_exit(&mut runtime, service::new_full(config, executor)?, exit)?,
+			}
+		}
+	}
+	Ok(())
+}
+
+fn run_until_exit<C, E>(
+	runtime: &mut Runtime,
+	service: service::Service<C>,
+	e: E,
+) -> error::Result<()>
+	where
+		C: service::Components,
+		E: IntoExit,
+{
+	let (exit_send, exit) = exit_future::signal();
+
+	let executor = runtime.executor();
+	cli::informant::start(&service, exit.clone(), executor.clone());
+
+	let _ = runtime.block_on(e.into_exit());
+	exit_send.fire();
+	Ok(())
+}

substrate/node/consensus/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "node-consensus"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+futures = "0.1.17"
+parking_lot = "0.4"
+tokio = "0.1.7"
+error-chain = "0.12"
+log = "0.3"
+exit-future = "0.1"
+rhododendron = "0.3"
+node-api = { path = "../api" }
+node-primitives = { path = "../primitives" }
+node-runtime = { path = "../runtime" }
+node-transaction-pool = { path = "../transaction-pool" }
+substrate-bft = { path = "../../core/bft" }
+parity-codec = { path = "../../codec" }
+substrate-primitives = { path = "../../core/primitives" }
+substrate-client = { path = "../../core/client" }
+sr-primitives = { path = "../../core/sr-primitives" }
+
+[dev-dependencies]
+substrate-keyring = { path = "../../core/keyring" }

substrate/node/consensus/README.adoc

@@ -0,0 +1,5 @@
+
+= Polkadot Consensus
+
+placeholder
+//TODO Write content :)

substrate/node/consensus/src/error.rs

@@ -0,0 +1,51 @@
+// 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/>.
+
+//! Errors that can occur during the consensus process.
+
+use primitives::AuthorityId;
+
+error_chain! {
+	links {
+		Api(::node_api::Error, ::node_api::ErrorKind);
+		Bft(::bft::Error, ::bft::ErrorKind);
+	}
+
+	errors {
+		NotValidator(id: AuthorityId) {
+			description("Local account ID not a validator at this block."),
+			display("Local account ID ({:?}) not a validator at this block.", id),
+		}
+		PrematureDestruction {
+			description("Proposer destroyed before finishing proposing or evaluating"),
+			display("Proposer destroyed before finishing proposing or evaluating"),
+		}
+		Timer(e: ::tokio::timer::Error) {
+			description("Failed to register or resolve async timer."),
+			display("Timer failed: {}", e),
+		}
+		Executor(e: ::futures::future::ExecuteErrorKind) {
+			description("Unable to dispatch agreement future"),
+			display("Unable to dispatch agreement future: {:?}", e),
+		}
+	}
+}
+
+impl From<::bft::InputStreamConcluded> for Error {
+	fn from(err: ::bft::InputStreamConcluded) -> Self {
+		::bft::Error::from(err).into()
+	}
+}

substrate/node/consensus/src/evaluation.rs

@@ -0,0 +1,96 @@
+// 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/>.
+
+//! Block evaluation and evaluation errors.
+
+use super::MAX_TRANSACTIONS_SIZE;
+
+use codec::{Decode, Encode};
+use node_runtime::{Block as GenericBlock, CheckedBlock};
+use node_primitives::{Block, Hash, BlockNumber, Timestamp};
+
+error_chain! {
+	links {
+		Api(::node_api::Error, ::node_api::ErrorKind);
+	}
+
+	errors {
+		BadProposalFormat {
+			description("Proposal provided not a block."),
+			display("Proposal provided not a block."),
+		}
+		TimestampInFuture {
+			description("Proposal had timestamp too far in the future."),
+			display("Proposal had timestamp too far in the future."),
+		}
+		WrongParentHash(expected: Hash, got: Hash) {
+			description("Proposal had wrong parent hash."),
+			display("Proposal had wrong parent hash. Expected {:?}, got {:?}", expected, got),
+		}
+		WrongNumber(expected: BlockNumber, got: BlockNumber) {
+			description("Proposal had wrong number."),
+			display("Proposal had wrong number. Expected {:?}, got {:?}", expected, got),
+		}
+		ProposalTooLarge(size: usize) {
+			description("Proposal exceeded the maximum size."),
+			display(
+				"Proposal exceeded the maximum size of {} by {} bytes.",
+				MAX_TRANSACTIONS_SIZE, size.saturating_sub(MAX_TRANSACTIONS_SIZE)
+			),
+		}
+	}
+}
+
+/// Attempt to evaluate a substrate block as a node block, returning error
+/// upon any initial validity checks failing.
+pub fn evaluate_initial(
+	proposal: &Block,
+	now: Timestamp,
+	parent_hash: &Hash,
+	parent_number: BlockNumber,
+) -> Result<CheckedBlock> {
+	const MAX_TIMESTAMP_DRIFT: Timestamp = 60;
+
+	let encoded = Encode::encode(proposal);
+	let proposal = GenericBlock::decode(&mut &encoded[..])
+		.and_then(|b| CheckedBlock::new(b).ok())
+		.ok_or_else(|| ErrorKind::BadProposalFormat)?;
+
+	let transactions_size = proposal.extrinsics.iter().fold(0, |a, tx| {
+		a + Encode::encode(tx).len()
+	});
+
+	if transactions_size > MAX_TRANSACTIONS_SIZE {
+		bail!(ErrorKind::ProposalTooLarge(transactions_size))
+	}
+
+	if proposal.header.parent_hash != *parent_hash {
+		bail!(ErrorKind::WrongParentHash(*parent_hash, proposal.header.parent_hash));
+	}
+
+	if proposal.header.number != parent_number + 1 {
+		bail!(ErrorKind::WrongNumber(parent_number + 1, proposal.header.number));
+	}
+
+	let block_timestamp = proposal.timestamp();
+
+	// lenient maximum -- small drifts will just be delayed using a timer.
+	if block_timestamp > now + MAX_TIMESTAMP_DRIFT {
+		bail!(ErrorKind::TimestampInFuture)
+	}
+
+	Ok(proposal)
+}

substrate/node/consensus/src/lib.rs

@@ -0,0 +1,444 @@
+// 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/>.
+
+//! This service uses BFT consensus provided by the substrate.
+
+extern crate parking_lot;
+extern crate node_api;
+extern crate node_transaction_pool as transaction_pool;
+extern crate node_runtime;
+extern crate node_primitives;
+
+extern crate substrate_bft as bft;
+extern crate parity_codec as codec;
+extern crate substrate_primitives as primitives;
+extern crate sr_primitives as runtime_primitives;
+extern crate substrate_client as client;
+
+extern crate exit_future;
+extern crate tokio;
+extern crate rhododendron;
+
+#[macro_use]
+extern crate error_chain;
+extern crate futures;
+
+#[macro_use]
+extern crate log;
+
+#[cfg(test)]
+extern crate substrate_keyring;
+
+use std::sync::Arc;
+use std::time::{self, Duration, Instant};
+
+use codec::{Decode, Encode};
+use node_api::Api;
+use node_primitives::{AccountId, Hash, Block, BlockId, BlockNumber, Header, Timestamp, SessionKey};
+use primitives::{AuthorityId, ed25519};
+use transaction_pool::TransactionPool;
+use tokio::runtime::TaskExecutor;
+use tokio::timer::Delay;
+
+use futures::prelude::*;
+use futures::future;
+use parking_lot::RwLock;
+
+pub use self::error::{ErrorKind, Error};
+pub use self::offline_tracker::OfflineTracker;
+pub use service::Service;
+
+mod evaluation;
+mod error;
+mod offline_tracker;
+mod service;
+
+/// Shared offline validator tracker.
+pub type SharedOfflineTracker = Arc<RwLock<OfflineTracker>>;
+
+// block size limit.
+const MAX_TRANSACTIONS_SIZE: usize = 4 * 1024 * 1024;
+
+/// A long-lived network which can create BFT message routing processes on demand.
+pub trait Network {
+	/// The input stream of BFT messages. Should never logically conclude.
+	type Input: Stream<Item=bft::Communication<Block>,Error=Error>;
+	/// The output sink of BFT messages. Messages sent here should eventually pass to all
+	/// current authorities.
+	type Output: Sink<SinkItem=bft::Communication<Block>,SinkError=Error>;
+
+	/// Instantiate input and output streams.
+	fn communication_for(
+		&self,
+		validators: &[SessionKey],
+		local_id: SessionKey,
+		parent_hash: Hash,
+		task_executor: TaskExecutor
+	) -> (Self::Input, Self::Output);
+}
+
+/// Proposer factory.
+pub struct ProposerFactory<N, P>
+	where
+		P: Api + Send + Sync + 'static
+{
+	/// The client instance.
+	pub client: Arc<P>,
+	/// The transaction pool.
+	pub transaction_pool: Arc<TransactionPool<P>>,
+	/// The backing network handle.
+	pub network: N,
+	/// handle to remote task executor
+	pub handle: TaskExecutor,
+	/// Offline-tracker.
+	pub offline: SharedOfflineTracker,
+}
+
+impl<N, P> bft::Environment<Block> for ProposerFactory<N, P>
+	where
+		N: Network,
+		P: Api + Send + Sync + 'static,
+{
+	type Proposer = Proposer<P>;
+	type Input = N::Input;
+	type Output = N::Output;
+	type Error = Error;
+
+	fn init(
+		&self,
+		parent_header: &Header,
+		authorities: &[AuthorityId],
+		sign_with: Arc<ed25519::Pair>,
+	) -> Result<(Self::Proposer, Self::Input, Self::Output), Error> {
+		use runtime_primitives::traits::{Hash as HashT, BlakeTwo256};
+
+		// force delay in evaluation this long.
+		const FORCE_DELAY: Timestamp = 5;
+
+		let parent_hash = parent_header.hash().into();
+
+		let id = BlockId::hash(parent_hash);
+		let random_seed = self.client.random_seed(&id)?;
+		let random_seed = BlakeTwo256::hash(&*random_seed);
+
+		let validators = self.client.validators(&id)?;
+		self.offline.write().note_new_block(&validators[..]);
+
+		info!("Starting consensus session on top of parent {:?}", parent_hash);
+
+		let local_id = sign_with.public().0.into();
+		let (input, output) = self.network.communication_for(
+			authorities,
+			local_id,
+			parent_hash.clone(),
+			self.handle.clone(),
+		);
+		let now = Instant::now();
+		let proposer = Proposer {
+			client: self.client.clone(),
+			start: now,
+			local_key: sign_with,
+			parent_hash,
+			parent_id: id,
+			parent_number: parent_header.number,
+			random_seed,
+			transaction_pool: self.transaction_pool.clone(),
+			offline: self.offline.clone(),
+			validators,
+			minimum_timestamp: current_timestamp() + FORCE_DELAY,
+		};
+
+		Ok((proposer, input, output))
+	}
+}
+
+/// The proposer logic.
+pub struct Proposer<C: Api + Send + Sync> {
+	client: Arc<C>,
+	start: Instant,
+	local_key: Arc<ed25519::Pair>,
+	parent_hash: Hash,
+	parent_id: BlockId,
+	parent_number: BlockNumber,
+	random_seed: Hash,
+	transaction_pool: Arc<TransactionPool<C>>,
+	offline: SharedOfflineTracker,
+	validators: Vec<AccountId>,
+	minimum_timestamp: u64,
+}
+
+impl<C: Api + Send + Sync> Proposer<C> {
+	fn primary_index(&self, round_number: usize, len: usize) -> usize {
+		use primitives::uint::U256;
+
+		let big_len = U256::from(len);
+		let offset = U256::from_big_endian(&self.random_seed.0) % big_len;
+		let offset = offset.low_u64() as usize + round_number;
+		offset % len
+	}
+}
+
+impl<C> bft::Proposer<Block> for Proposer<C>
+	where
+		C: Api + Send + Sync,
+{
+	type Create = Result<Block, Error>;
+	type Error = Error;
+	type Evaluate = Box<Future<Item=bool, Error=Error>>;
+
+	fn propose(&self) -> Result<Block, Error> {
+		use node_api::BlockBuilder;
+		use runtime_primitives::traits::{Hash as HashT, BlakeTwo256};
+		use node_primitives::InherentData;
+
+		const MAX_VOTE_OFFLINE_SECONDS: Duration = Duration::from_secs(60);
+
+		// TODO: handle case when current timestamp behind that in state.
+		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.validators[..])
+		};
+
+		if !offline_indices.is_empty() {
+			info!(
+				"Submitting offline validators {:?} for slash-vote",
+				offline_indices.iter().map(|&i| self.validators[i as usize]).collect::<Vec<_>>(),
+				)
+		}
+
+		let inherent_data = InherentData {
+			timestamp,
+			offline_indices,
+		};
+
+		let mut block_builder = self.client.build_block(&self.parent_id, inherent_data)?;
+
+		{
+			let mut unqueue_invalid = Vec::new();
+			let result = self.transaction_pool.cull_and_get_pending(&BlockId::hash(self.parent_hash), |pending_iterator| {
+				let mut pending_size = 0;
+				for pending in pending_iterator {
+					if pending_size + pending.verified.encoded_size() >= MAX_TRANSACTIONS_SIZE { break }
+
+					match block_builder.push_extrinsic(pending.original.clone()) {
+						Ok(()) => {
+							pending_size += pending.verified.encoded_size();
+						}
+						Err(e) => {
+							trace!(target: "transaction-pool", "Invalid transaction: {}", e);
+							unqueue_invalid.push(pending.verified.hash().clone());
+						}
+					}
+				}
+			});
+			if let Err(e) = result {
+				warn!("Unable to get the pending set: {:?}", e);
+			}
+
+			self.transaction_pool.remove(&unqueue_invalid, false);
+		}
+
+		let block = block_builder.bake()?;
+
+		info!("Proposing block [number: {}; hash: {}; parent_hash: {}; extrinsics: [{}]]",
+			  block.header.number,
+			  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,
+			timestamp,
+			&self.parent_hash,
+			self.parent_number,
+		).is_ok());
+
+		Ok(substrate_block)
+	}
+
+	fn evaluate(&self, unchecked_proposal: &Block) -> Self::Evaluate {
+		debug!(target: "bft", "evaluating block on top of parent ({}, {:?})", self.parent_number, self.parent_hash);
+
+		let current_timestamp = current_timestamp();
+
+		// do initial serialization and structural integrity checks.
+		let maybe_proposal = evaluation::evaluate_initial(
+			unchecked_proposal,
+			current_timestamp,
+			&self.parent_hash,
+			self.parent_number,
+		);
+
+		let proposal = match maybe_proposal {
+			Ok(p) => p,
+			Err(e) => {
+				// TODO: these errors are easily re-checked in runtime.
+				debug!(target: "bft", "Invalid proposal: {:?}", e);
+				return Box::new(future::ok(false));
+			}
+		};
+
+		let vote_delays = {
+			let now = Instant::now();
+
+			// the duration until the given timestamp is current
+			let proposed_timestamp = ::std::cmp::max(self.minimum_timestamp, proposal.timestamp());
+			let timestamp_delay = if proposed_timestamp > current_timestamp {
+				let delay_s = proposed_timestamp - current_timestamp;
+				debug!(target: "bft", "Delaying evaluation of proposal for {} seconds", delay_s);
+				Some(now + Duration::from_secs(delay_s))
+			} else {
+				None
+			};
+
+			match timestamp_delay {
+				Some(duration) => future::Either::A(
+					Delay::new(duration).map_err(|e| Error::from(ErrorKind::Timer(e)))
+				),
+				None => future::Either::B(future::ok(())),
+			}
+		};
+
+		// refuse to vote if this block says a validator is offline that we
+		// think isn't.
+		let offline = proposal.noted_offline();
+		if !self.offline.read().check_consistency(&self.validators[..], offline) {
+			return Box::new(futures::empty());
+		}
+
+		// evaluate whether the block is actually valid.
+		// TODO: is it better to delay this until the delays are finished?
+		let evaluated = self.client
+			.evaluate_block(&self.parent_id, unchecked_proposal.clone())
+			.map_err(Into::into);
+
+		let future = future::result(evaluated).and_then(move |good| {
+			let end_result = future::ok(good);
+			if good {
+				// delay a "good" vote.
+				future::Either::A(vote_delays.and_then(|_| end_result))
+			} else {
+				// don't delay a "bad" evaluation.
+				future::Either::B(end_result)
+			}
+		});
+
+		Box::new(future) as Box<_>
+	}
+
+	fn round_proposer(&self, round_number: usize, authorities: &[AuthorityId]) -> AuthorityId {
+		let offset = self.primary_index(round_number, authorities.len());
+		let proposer = authorities[offset].clone();
+		trace!(target: "bft", "proposer for round {} is {}", round_number, proposer);
+
+		proposer
+	}
+
+	fn import_misbehavior(&self, misbehavior: Vec<(AuthorityId, bft::Misbehavior<Hash>)>) {
+		use rhododendron::Misbehavior as GenericMisbehavior;
+		use runtime_primitives::bft::{MisbehaviorKind, MisbehaviorReport};
+		use node_primitives::UncheckedExtrinsic as GenericExtrinsic;
+		use node_runtime::{Call, UncheckedExtrinsic, ConsensusCall};
+
+		let local_id = self.local_key.public().0.into();
+		let mut next_index = {
+			let cur_index = self.transaction_pool.cull_and_get_pending(&BlockId::hash(self.parent_hash), |pending| pending
+				.filter(|tx| tx.verified.sender == local_id)
+				.last()
+				.map(|tx| Ok(tx.verified.index()))
+				.unwrap_or_else(|| self.client.index(&self.parent_id, local_id))
+			);
+
+			match cur_index {
+				Ok(Ok(cur_index)) => cur_index + 1,
+				Ok(Err(e)) => {
+					warn!(target: "consensus", "Error computing next transaction index: {}", e);
+					return;
+				}
+				Err(e) => {
+					warn!(target: "consensus", "Error computing next transaction index: {}", e);
+					return;
+				}
+			}
+		};
+
+		for (target, misbehavior) in misbehavior {
+			let report = MisbehaviorReport {
+				parent_hash: self.parent_hash,
+				parent_number: self.parent_number,
+				target,
+				misbehavior: match misbehavior {
+					GenericMisbehavior::ProposeOutOfTurn(_, _, _) => continue,
+					GenericMisbehavior::DoublePropose(_, _, _) => continue,
+					GenericMisbehavior::DoublePrepare(round, (h1, s1), (h2, s2))
+						=> MisbehaviorKind::BftDoublePrepare(round as u32, (h1, s1.signature), (h2, s2.signature)),
+					GenericMisbehavior::DoubleCommit(round, (h1, s1), (h2, s2))
+						=> MisbehaviorKind::BftDoubleCommit(round as u32, (h1, s1.signature), (h2, s2.signature)),
+				}
+			};
+			let payload = (next_index, Call::Consensus(ConsensusCall::report_misbehavior(report)));
+			let signature = self.local_key.sign(&payload.encode()).into();
+			next_index += 1;
+
+			let local_id = self.local_key.public().0.into();
+			let extrinsic = UncheckedExtrinsic {
+				signature: Some((node_runtime::RawAddress::Id(local_id), signature)),
+				index: payload.0,
+				function: payload.1,
+			};
+			let uxt: GenericExtrinsic = Decode::decode(&mut extrinsic.encode().as_slice()).expect("Encoded extrinsic is valid");
+			self.transaction_pool.submit_one(&BlockId::hash(self.parent_hash), uxt)
+				.expect("locally signed extrinsic is valid; qed");
+		}
+	}
+
+	fn on_round_end(&self, round_number: usize, was_proposed: bool) {
+		let primary_validator = self.validators[
+			self.primary_index(round_number, self.validators.len())
+		];
+
+
+		// alter the message based on whether we think the empty proposer was forced to skip the round.
+		// this is determined by checking if our local validator would have been forced to skip the round.
+		if !was_proposed {
+			let public = ed25519::Public::from_raw(primary_validator.0);
+			info!(
+				"Potential Offline Validator: {} failed to propose during assigned slot: {}",
+				public,
+				round_number,
+			);
+		}
+
+		self.offline.write().note_round_end(primary_validator, was_proposed);
+	}
+}
+
+fn current_timestamp() -> Timestamp {
+	time::SystemTime::now().duration_since(time::UNIX_EPOCH)
+		.expect("now always later than unix epoch; qed")
+		.as_secs()
+}

substrate/node/consensus/src/offline_tracker.rs

@@ -0,0 +1,137 @@
+// 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/>.
+
+//! Tracks offline validators.
+
+use node_primitives::AccountId;
+
+use std::collections::HashMap;
+use std::time::{Instant, Duration};
+
+// time before we report a validator.
+const REPORT_TIME: Duration = Duration::from_secs(60 * 5);
+
+struct Observed {
+	last_round_end: Instant,
+	offline_since: Instant,
+}
+
+impl Observed {
+	fn new() -> Observed {
+		let now = Instant::now();
+		Observed {
+			last_round_end: now,
+			offline_since: now,
+		}
+	}
+
+	fn note_round_end(&mut self, was_online: bool) {
+		let now = Instant::now();
+
+		self.last_round_end = now;
+		if was_online {
+			self.offline_since = now;
+		}
+	}
+
+	fn is_active(&self) -> bool {
+		// can happen if clocks are not monotonic
+		if self.offline_since > self.last_round_end { return true }
+		self.last_round_end.duration_since(self.offline_since) < REPORT_TIME
+	}
+}
+
+/// Tracks offline validators and can issue a report for those offline.
+pub struct OfflineTracker {
+	observed: HashMap<AccountId, Observed>,
+}
+
+impl OfflineTracker {
+	/// Create a new tracker.
+	pub fn new() -> Self {
+		OfflineTracker { observed: HashMap::new() }
+	}
+
+	/// Note new consensus is starting with the given set of validators.
+	pub fn note_new_block(&mut self, validators: &[AccountId]) {
+		use std::collections::HashSet;
+
+		let set: HashSet<_> = validators.iter().cloned().collect();
+		self.observed.retain(|k, _| set.contains(k));
+	}
+
+	/// Note that a round has ended.
+	pub fn note_round_end(&mut self, validator: AccountId, was_online: bool) {
+		self.observed.entry(validator)
+			.or_insert_with(Observed::new)
+			.note_round_end(was_online);
+	}
+
+	/// Generate a vector of indices for offline account IDs.
+	pub fn reports(&self, validators: &[AccountId]) -> Vec<u32> {
+		validators.iter()
+			.enumerate()
+			.filter_map(|(i, v)| if self.is_online(v) {
+				None
+			} else {
+				Some(i as u32)
+			})
+			.collect()
+	}
+
+	/// Whether reports on a validator set are consistent with our view of things.
+	pub fn check_consistency(&self, validators: &[AccountId], reports: &[u32]) -> bool {
+		reports.iter().cloned().all(|r| {
+			let v = match validators.get(r as usize) {
+				Some(v) => v,
+				None => return false,
+			};
+
+			// we must think all validators reported externally are offline.
+			let thinks_online = self.is_online(v);
+			!thinks_online
+		})
+	}
+
+	fn is_online(&self, v: &AccountId) -> bool {
+		self.observed.get(v).map(Observed::is_active).unwrap_or(true)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn validator_offline() {
+		let mut tracker = OfflineTracker::new();
+		let v = [0; 32].into();
+		let v2 = [1; 32].into();
+		let v3 = [2; 32].into();
+		tracker.note_round_end(v, true);
+		tracker.note_round_end(v2, true);
+		tracker.note_round_end(v3, true);
+
+		let slash_time = REPORT_TIME + Duration::from_secs(5);
+		tracker.observed.get_mut(&v).unwrap().offline_since -= slash_time;
+		tracker.observed.get_mut(&v2).unwrap().offline_since -= slash_time;
+
+		assert_eq!(tracker.reports(&[v, v2, v3]), vec![0, 1]);
+
+		tracker.note_new_block(&[v, v3]);
+		assert_eq!(tracker.reports(&[v, v2, v3]), vec![0]);
+	}
+}

substrate/node/consensus/src/service.rs

@@ -0,0 +1,172 @@
+// 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/>.
+
+//! Consensus service.
+
+/// Consensus service. A long running service that manages BFT agreement
+/// the network.
+use std::thread;
+use std::time::{Duration, Instant};
+use std::sync::Arc;
+
+use bft::{self, BftService};
+use client::{BlockchainEvents, ChainHead, BlockBody};
+use ed25519;
+use futures::prelude::*;
+use node_api::Api;
+use node_primitives::{Block, Header};
+use transaction_pool::TransactionPool;
+
+use tokio::executor::current_thread::TaskExecutor as LocalThreadHandle;
+use tokio::runtime::TaskExecutor as ThreadPoolHandle;
+use tokio::runtime::current_thread::Runtime as LocalRuntime;
+use tokio::timer::Interval;
+
+use super::{Network, ProposerFactory};
+use error;
+
+const TIMER_DELAY_MS: u64 = 5000;
+const TIMER_INTERVAL_MS: u64 = 500;
+
+// spin up an instance of BFT agreement on the current thread's executor.
+// panics if there is no current thread executor.
+fn start_bft<F, C>(
+	header: Header,
+	bft_service: Arc<BftService<Block, F, C>>,
+) where
+	F: bft::Environment<Block> + 'static,
+	C: bft::BlockImport<Block> + bft::Authorities<Block> + 'static,
+	F::Error: ::std::fmt::Debug,
+	<F::Proposer as bft::Proposer<Block>>::Error: ::std::fmt::Display + Into<error::Error>,
+	<F as bft::Environment<Block>>::Error: ::std::fmt::Display
+{
+	let mut handle = LocalThreadHandle::current();
+	match bft_service.build_upon(&header) {
+		Ok(Some(bft_work)) => if let Err(e) = handle.spawn_local(Box::new(bft_work)) {
+		    warn!(target: "bft", "Couldn't initialize BFT agreement: {:?}", e);
+		}
+		Ok(None) => trace!(target: "bft", "Could not start agreement on top of {}", header.hash()),
+		Err(e) => warn!(target: "bft", "BFT agreement error: {}", e),
+ 	}
+}
+
+/// Consensus service. Starts working when created.
+pub struct Service {
+	thread: Option<thread::JoinHandle<()>>,
+	exit_signal: Option<::exit_future::Signal>,
+}
+
+impl Service {
+	/// Create and start a new instance.
+	pub fn new<A, C, N>(
+		client: Arc<C>,
+		api: Arc<A>,
+		network: N,
+		transaction_pool: Arc<TransactionPool<A>>,
+		thread_pool: ThreadPoolHandle,
+		key: ed25519::Pair,
+	) -> Service
+		where
+			A: Api + Send + Sync + 'static,
+			C: BlockchainEvents<Block> + ChainHead<Block> + BlockBody<Block>,
+			C: bft::BlockImport<Block> + bft::Authorities<Block> + Send + Sync + 'static,
+			N: Network + Send + 'static,
+	{
+		use parking_lot::RwLock;
+		use super::OfflineTracker;
+
+		let (signal, exit) = ::exit_future::signal();
+		let thread = thread::spawn(move || {
+			let mut runtime = LocalRuntime::new().expect("Could not create local runtime");
+			let key = Arc::new(key);
+
+			let factory = ProposerFactory {
+				client: api.clone(),
+				transaction_pool: transaction_pool.clone(),
+				network,
+				handle: thread_pool.clone(),
+				offline: Arc::new(RwLock::new(OfflineTracker::new())),
+			};
+			let bft_service = Arc::new(BftService::new(client.clone(), key, factory));
+
+			let notifications = {
+				let client = client.clone();
+				let bft_service = bft_service.clone();
+
+				client.import_notification_stream().for_each(move |notification| {
+					if notification.is_new_best {
+						start_bft(notification.header, bft_service.clone());
+					}
+					Ok(())
+				})
+			};
+
+			let interval = Interval::new(
+				Instant::now() + Duration::from_millis(TIMER_DELAY_MS),
+				Duration::from_millis(TIMER_INTERVAL_MS),
+			);
+
+			let mut prev_best = match client.best_block_header() {
+				Ok(header) => header.hash(),
+				Err(e) => {
+					warn!("Cant's start consensus service. Error reading best block header: {:?}", e);
+					return;
+				}
+			};
+
+			let timed = {
+				let c = client.clone();
+				let s = bft_service.clone();
+
+				interval.map_err(|e| debug!(target: "bft", "Timer error: {:?}", e)).for_each(move |_| {
+					if let Ok(best_block) = c.best_block_header() {
+						let hash = best_block.hash();
+
+						if hash == prev_best {
+							debug!(target: "bft", "Starting consensus round after a timeout");
+							start_bft(best_block, s.clone());
+						}
+						prev_best = hash;
+					}
+					Ok(())
+				})
+			};
+
+			runtime.spawn(notifications);
+			runtime.spawn(timed);
+
+			if let Err(e) = runtime.block_on(exit) {
+				debug!("BFT event loop error {:?}", e);
+			}
+		});
+		Service {
+			thread: Some(thread),
+			exit_signal: Some(signal),
+		}
+	}
+}
+
+impl Drop for Service {
+	fn drop(&mut self) {
+		if let Some(signal) = self.exit_signal.take() {
+			signal.fire();
+		}
+
+		if let Some(thread) = self.thread.take() {
+			thread.join().expect("The service thread has panicked");
+		}
+	}
+}

substrate/node/executor/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "node-executor"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node implementation in Rust."
+
+[dependencies]
+hex-literal = "0.1"
+triehash = "0.2"
+parity-codec = { path = "../../codec" }
+sr-io = { path = "../../core/sr-io" }
+substrate-state-machine = { path = "../../core/state-machine" }
+substrate-executor = { path = "../../core/executor" }
+substrate-primitives = { path = "../../core/primitives" }
+node-primitives = { path = "../primitives" }
+node-runtime = { path = "../runtime" }
+
+[dev-dependencies]
+substrate-keyring = { path = "../../core/keyring" }
+sr-primitives = { path = "../../core/sr-primitives" }
+srml-support = { path = "../../srml/support" }
+srml-balances = { path = "../../srml/balances" }
+srml-session = { path = "../../srml/session" }
+srml-staking = { path = "../../srml/staking" }
+srml-system = { path = "../../srml/system" }
+srml-consensus = { path = "../../srml/consensus" }
+srml-timestamp = { path = "../../srml/timestamp" }
+srml-treasury = { path = "../../srml/treasury" }

substrate/node/executor/src/lib.rs

@@ -0,0 +1,524 @@
+// 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/>.
+
+//! A `CodeExecutor` specialisation which uses natively compiled runtime when the wasm to be
+//! executed is equivalent to the natively compiled code.
+
+extern crate node_runtime;
+#[macro_use] extern crate substrate_executor;
+extern crate parity_codec as codec;
+extern crate substrate_state_machine as state_machine;
+extern crate sr_io as runtime_io;
+extern crate substrate_primitives as primitives;
+extern crate node_primitives;
+extern crate triehash;
+
+#[cfg(test)] extern crate substrate_keyring as keyring;
+#[cfg(test)] extern crate sr_primitives as runtime_primitives;
+#[cfg(test)] extern crate srml_support as runtime_support;
+#[cfg(test)] extern crate srml_balances as balances;
+#[cfg(test)] extern crate srml_session as session;
+#[cfg(test)] extern crate srml_staking as staking;
+#[cfg(test)] extern crate srml_system as system;
+#[cfg(test)] extern crate srml_consensus as consensus;
+#[cfg(test)] extern crate srml_timestamp as timestamp;
+#[cfg(test)] extern crate srml_treasury as treasury;
+#[cfg(test)] #[macro_use] extern crate hex_literal;
+
+pub use substrate_executor::NativeExecutor;
+native_executor_instance!(pub Executor, node_runtime::api::dispatch, node_runtime::VERSION, include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/node_runtime.compact.wasm"));
+
+#[cfg(test)]
+mod tests {
+	use runtime_io;
+	use super::Executor;
+	use substrate_executor::{WasmExecutor, NativeExecutionDispatch};
+	use codec::{Encode, Decode, Joiner};
+	use keyring::Keyring;
+	use runtime_support::{Hashable, StorageValue, StorageMap};
+	use state_machine::{CodeExecutor, TestExternalities};
+	use primitives::{twox_128, Blake2Hasher, ed25519::{Public, Pair}};
+	use node_primitives::{Hash, BlockNumber, AccountId};
+	use runtime_primitives::traits::Header as HeaderT;
+	use runtime_primitives::{ApplyOutcome, ApplyError, ApplyResult};
+	use {balances, staking, session, system, consensus, timestamp, treasury};
+	use system::{EventRecord, Phase};
+	use node_runtime::{Header, Block, UncheckedExtrinsic, CheckedExtrinsic, Call, Runtime, Balances,
+		BuildStorage, GenesisConfig, BalancesConfig, SessionConfig, StakingConfig, System, Event};
+
+	const BLOATY_CODE: &[u8] = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/node_runtime.wasm");
+	const COMPACT_CODE: &[u8] = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/node_runtime.compact.wasm");
+
+	// TODO: move into own crate.
+	macro_rules! map {
+		($( $name:expr => $value:expr ),*) => (
+			vec![ $( ( $name, $value ) ),* ].into_iter().collect()
+		)
+	}
+
+	fn alice() -> AccountId {
+		AccountId::from(Keyring::Alice.to_raw_public())
+	}
+
+	fn bob() -> AccountId {
+		AccountId::from(Keyring::Bob.to_raw_public())
+	}
+
+	fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
+		match xt.signed {
+			Some(signed) => {
+				let payload = (xt.index, xt.function);
+				let pair = Pair::from(Keyring::from_public(Public::from_raw(signed.clone().into())).unwrap());
+				let signature = pair.sign(&payload.encode()).into();
+				UncheckedExtrinsic {
+					signature: Some((balances::address::Address::Id(signed), signature)),
+					index: payload.0,
+					function: payload.1,
+				}
+			}
+			None => UncheckedExtrinsic {
+				signature: None,
+				index: xt.index,
+				function: xt.function,
+			},
+		}
+	}
+
+	fn xt() -> UncheckedExtrinsic {
+		sign(CheckedExtrinsic {
+			signed: Some(alice()),
+			index: 0,
+			function: Call::Balances(balances::Call::transfer::<Runtime>(bob().into(), 69)),
+		})
+	}
+
+	fn from_block_number(n: u64) -> Header {
+		Header::new(n, Default::default(), Default::default(), [69; 32].into(), Default::default())
+	}
+
+	fn executor() -> ::substrate_executor::NativeExecutor<Executor> {
+		::substrate_executor::NativeExecutor::new()
+	}
+
+	#[test]
+	fn panic_execution_with_foreign_code_gives_error() {
+		let mut t: TestExternalities<Blake2Hasher> = map![
+			twox_128(&<balances::FreeBalance<Runtime>>::key_for(alice())).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TotalIssuance<Runtime>>::key()).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TransactionBaseFee<Runtime>>::key()).to_vec() => vec![70u8; 8],
+			twox_128(<balances::TransactionByteFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::ExistentialDeposit<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransferFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::NextEnumSet<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(&<system::BlockHash<Runtime>>::key_for(0)).to_vec() => vec![0u8; 32]
+		];
+
+		let r = executor().call(&mut t, 8, BLOATY_CODE, "initialise_block", &vec![].and(&from_block_number(1u64)), true).0;
+		assert!(r.is_ok());
+		let v = executor().call(&mut t, 8, BLOATY_CODE, "apply_extrinsic", &vec![].and(&xt()), true).0.unwrap();
+		let r = ApplyResult::decode(&mut &v[..]).unwrap();
+		assert_eq!(r, Err(ApplyError::CantPay));
+	}
+
+	#[test]
+	fn bad_extrinsic_with_native_equivalent_code_gives_error() {
+		let mut t: TestExternalities<Blake2Hasher> = map![
+			twox_128(&<balances::FreeBalance<Runtime>>::key_for(alice())).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TotalIssuance<Runtime>>::key()).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TransactionBaseFee<Runtime>>::key()).to_vec() => vec![70u8; 8],
+			twox_128(<balances::TransactionByteFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::ExistentialDeposit<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransferFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::NextEnumSet<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(&<system::BlockHash<Runtime>>::key_for(0)).to_vec() => vec![0u8; 32]
+		];
+
+		let r = executor().call(&mut t, 8, COMPACT_CODE, "initialise_block", &vec![].and(&from_block_number(1u64)), true).0;
+		assert!(r.is_ok());
+		let v = executor().call(&mut t, 8, COMPACT_CODE, "apply_extrinsic", &vec![].and(&xt()), true).0.unwrap();
+		let r = ApplyResult::decode(&mut &v[..]).unwrap();
+		assert_eq!(r, Err(ApplyError::CantPay));
+	}
+
+	#[test]
+	fn successful_execution_with_native_equivalent_code_gives_ok() {
+		let mut t: TestExternalities<Blake2Hasher> = map![
+			twox_128(&<balances::FreeBalance<Runtime>>::key_for(alice())).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TotalIssuance<Runtime>>::key()).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TransactionBaseFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransactionByteFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::ExistentialDeposit<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransferFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::NextEnumSet<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(&<system::BlockHash<Runtime>>::key_for(0)).to_vec() => vec![0u8; 32]
+		];
+
+		let r = executor().call(&mut t, 8, COMPACT_CODE, "initialise_block", &vec![].and(&from_block_number(1u64)), true).0;
+		assert!(r.is_ok());
+		let r = executor().call(&mut t, 8, COMPACT_CODE, "apply_extrinsic", &vec![].and(&xt()), true).0;
+		assert!(r.is_ok());
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(Balances::total_balance(&alice()), 42);
+			assert_eq!(Balances::total_balance(&bob()), 69);
+		});
+	}
+
+	#[test]
+	fn successful_execution_with_foreign_code_gives_ok() {
+		let mut t: TestExternalities<Blake2Hasher> = map![
+			twox_128(&<balances::FreeBalance<Runtime>>::key_for(alice())).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TotalIssuance<Runtime>>::key()).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TransactionBaseFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransactionByteFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::ExistentialDeposit<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransferFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::NextEnumSet<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(&<system::BlockHash<Runtime>>::key_for(0)).to_vec() => vec![0u8; 32]
+		];
+
+		let r = executor().call(&mut t, 8, BLOATY_CODE, "initialise_block", &vec![].and(&from_block_number(1u64)), true).0;
+		assert!(r.is_ok());
+		let r = executor().call(&mut t, 8, BLOATY_CODE, "apply_extrinsic", &vec![].and(&xt()), true).0;
+		assert!(r.is_ok());
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(Balances::total_balance(&alice()), 42);
+			assert_eq!(Balances::total_balance(&bob()), 69);
+		});
+	}
+
+	fn new_test_ext() -> TestExternalities<Blake2Hasher> {
+		use keyring::Keyring::*;
+		let three = [3u8; 32].into();
+		GenesisConfig {
+			consensus: Some(Default::default()),
+			system: Some(Default::default()),
+			balances: Some(BalancesConfig {
+				balances: vec![(alice(), 111)],
+				transaction_base_fee: 1,
+				transaction_byte_fee: 0,
+				existential_deposit: 0,
+				transfer_fee: 0,
+				creation_fee: 0,
+				reclaim_rebate: 0,
+			}),
+			session: Some(SessionConfig {
+				session_length: 2,
+				validators: vec![One.to_raw_public().into(), Two.to_raw_public().into(), three],
+			}),
+			staking: Some(StakingConfig {
+				sessions_per_era: 2,
+				current_era: 0,
+				intentions: vec![alice(), bob(), Charlie.to_raw_public().into()],
+				validator_count: 3,
+				minimum_validator_count: 0,
+				bonding_duration: 0,
+				offline_slash: 0,
+				session_reward: 0,
+				offline_slash_grace: 0,
+			}),
+			democracy: Some(Default::default()),
+			council: Some(Default::default()),
+			timestamp: Some(Default::default()),
+			treasury: Some(Default::default()),
+			contract: Some(Default::default()),
+		}.build_storage().unwrap().into()
+	}
+
+	fn construct_block(number: BlockNumber, parent_hash: Hash, state_root: Hash, extrinsics: Vec<CheckedExtrinsic>) -> (Vec<u8>, Hash) {
+		use triehash::ordered_trie_root;
+
+		let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
+		let extrinsics_root = ordered_trie_root::<Blake2Hasher, _, _>(extrinsics.iter().map(Encode::encode)).0.into();
+
+		let header = Header {
+			parent_hash,
+			number,
+			state_root,
+			extrinsics_root,
+			digest: Default::default(),
+		};
+		let hash = header.blake2_256();
+
+		(Block { header, extrinsics }.encode(), hash.into())
+	}
+
+	fn block1() -> (Vec<u8>, Hash) {
+		construct_block(
+			1,
+			[69u8; 32].into(),
+			hex!("1f058f699ad3187bcf7e9ed8e44464d7a5added0cd912d2679b9dab2e7a04053").into(),
+			vec![
+				CheckedExtrinsic {
+					signed: None,
+					index: 0,
+					function: Call::Timestamp(timestamp::Call::set(42)),
+				},
+				CheckedExtrinsic {
+					signed: Some(alice()),
+					index: 0,
+					function: Call::Balances(balances::Call::transfer(bob().into(), 69)),
+				},
+			]
+		)
+	}
+
+	fn block2() -> (Vec<u8>, Hash) {
+		construct_block(
+			2,
+			block1().1,
+			hex!("29fa1d0aa83662c571315af54b106c73823a31f759793803bf8929960b67b138").into(),
+			vec![
+				CheckedExtrinsic {
+					signed: None,
+					index: 0,
+					function: Call::Timestamp(timestamp::Call::set(52)),
+				},
+				CheckedExtrinsic {
+					signed: Some(bob()),
+					index: 0,
+					function: Call::Balances(balances::Call::transfer(alice().into(), 5)),
+				},
+				CheckedExtrinsic {
+					signed: Some(alice()),
+					index: 1,
+					function: Call::Balances(balances::Call::transfer(bob().into(), 15)),
+				}
+			]
+		)
+	}
+
+	fn block1big() -> (Vec<u8>, Hash) {
+		construct_block(
+			1,
+			[69u8; 32].into(),
+			hex!("fe0e07c7b054fe186387461d455d536860e9c71d6979fd9dbf755e96ce070d04").into(),
+			vec![
+				CheckedExtrinsic {
+					signed: None,
+					index: 0,
+					function: Call::Timestamp(timestamp::Call::set(42)),
+				},
+				CheckedExtrinsic {
+					signed: Some(alice()),
+					index: 0,
+					function: Call::Consensus(consensus::Call::remark(vec![0; 120000])),
+				}
+			]
+		)
+	}
+
+	#[test]
+	fn full_native_block_import_works() {
+		let mut t = new_test_ext();
+
+		executor().call(&mut t, 8, COMPACT_CODE, "execute_block", &block1().0, true).0.unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(Balances::total_balance(&alice()), 41);
+			assert_eq!(Balances::total_balance(&bob()), 69);
+			assert_eq!(System::events(), vec![
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(0),
+					event: Event::system(system::Event::ExtrinsicSuccess)
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(1),
+					event: Event::balances(balances::RawEvent::NewAccount(bob(), 1, balances::NewAccountOutcome::NoHint))
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(1),
+					event: Event::balances(balances::RawEvent::Transfer(
+						hex!["d172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f"].into(),
+						hex!["d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9"].into(),
+						69,
+						0
+					))
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(1),
+					event: Event::system(system::Event::ExtrinsicSuccess)
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::treasury(treasury::RawEvent::Spending(0))
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::treasury(treasury::RawEvent::Burnt(0))
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::treasury(treasury::RawEvent::Rollover(0))
+				}
+			]);
+		});
+
+		executor().call(&mut t, 8, COMPACT_CODE, "execute_block", &block2().0, true).0.unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(Balances::total_balance(&alice()), 30);
+			assert_eq!(Balances::total_balance(&bob()), 78);
+			assert_eq!(System::events(), vec![
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(0),
+					event: Event::system(system::Event::ExtrinsicSuccess)
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(1),
+					event: Event::balances(
+						balances::RawEvent::Transfer(
+							hex!["d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9"].into(),
+							hex!["d172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f"].into(),
+							5,
+							0
+						)
+					)
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(1),
+					event: Event::system(system::Event::ExtrinsicSuccess)
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(2),
+					event: Event::balances(
+						balances::RawEvent::Transfer(
+							hex!["d172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f"].into(),
+							hex!["d7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9"].into(),
+							15,
+							0
+						)
+					)
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(2),
+					event: Event::system(system::Event::ExtrinsicSuccess)
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::session(session::RawEvent::NewSession(1))
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::staking(staking::RawEvent::Reward(0))
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::treasury(treasury::RawEvent::Spending(0))
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::treasury(treasury::RawEvent::Burnt(0))
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: Event::treasury(treasury::RawEvent::Rollover(0))
+				}
+			]);
+		});
+	}
+
+	#[test]
+	fn full_wasm_block_import_works() {
+		let mut t = new_test_ext();
+
+		WasmExecutor::new().call(&mut t, 8, COMPACT_CODE, "execute_block", &block1().0).unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(Balances::total_balance(&alice()), 41);
+			assert_eq!(Balances::total_balance(&bob()), 69);
+		});
+
+		WasmExecutor::new().call(&mut t, 8, COMPACT_CODE, "execute_block", &block2().0).unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(Balances::total_balance(&alice()), 30);
+			assert_eq!(Balances::total_balance(&bob()), 78);
+		});
+	}
+
+	#[test]
+	fn wasm_big_block_import_fails() {
+		let mut t = new_test_ext();
+
+		let r = WasmExecutor::new().call(&mut t, 8, COMPACT_CODE, "execute_block", &block1big().0);
+		assert!(!r.is_ok());
+	}
+
+	#[test]
+	fn native_big_block_import_succeeds() {
+		let mut t = new_test_ext();
+
+		let r = Executor::new().call(&mut t, 8, COMPACT_CODE, "execute_block", &block1big().0, true).0;
+		assert!(r.is_ok());
+	}
+
+	#[test]
+	fn native_big_block_import_fails_on_fallback() {
+		let mut t = new_test_ext();
+
+		let r = Executor::new().call(&mut t, 8, COMPACT_CODE, "execute_block", &block1big().0, false).0;
+		assert!(!r.is_ok());
+	}
+
+	#[test]
+	fn panic_execution_gives_error() {
+		let mut t: TestExternalities<Blake2Hasher> = map![
+			twox_128(&<balances::FreeBalance<Runtime>>::key_for(alice())).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TotalIssuance<Runtime>>::key()).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TransactionBaseFee<Runtime>>::key()).to_vec() => vec![70u8; 8],
+			twox_128(<balances::TransactionByteFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::ExistentialDeposit<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransferFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::NextEnumSet<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(&<system::BlockHash<Runtime>>::key_for(0)).to_vec() => vec![0u8; 32]
+		];
+
+		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/node_runtime.wasm");
+		let r = WasmExecutor::new().call(&mut t, 8, &foreign_code[..], "initialise_block", &vec![].and(&from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = WasmExecutor::new().call(&mut t, 8, &foreign_code[..], "apply_extrinsic", &vec![].and(&xt())).unwrap();
+		let r = ApplyResult::decode(&mut &r[..]).unwrap();
+		assert_eq!(r, Err(ApplyError::CantPay));
+	}
+
+	#[test]
+	fn successful_execution_gives_ok() {
+		let mut t: TestExternalities<Blake2Hasher> = map![
+			twox_128(&<balances::FreeBalance<Runtime>>::key_for(alice())).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TotalIssuance<Runtime>>::key()).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+			twox_128(<balances::TransactionBaseFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransactionByteFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::ExistentialDeposit<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::TransferFee<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<balances::NextEnumSet<Runtime>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(&<system::BlockHash<Runtime>>::key_for(0)).to_vec() => vec![0u8; 32]
+		];
+
+		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/node_runtime.compact.wasm");
+		let r = WasmExecutor::new().call(&mut t, 8, &foreign_code[..], "initialise_block", &vec![].and(&from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = WasmExecutor::new().call(&mut t, 8, &foreign_code[..], "apply_extrinsic", &vec![].and(&xt())).unwrap();
+		let r = ApplyResult::decode(&mut &r[..]).unwrap();
+		assert_eq!(r, Ok(ApplyOutcome::Success));
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(Balances::total_balance(&alice()), 42);
+			assert_eq!(Balances::total_balance(&bob()), 69);
+		});
+	}
+}

substrate/node/network/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "node-network"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node networking protocol"
+
+[dependencies]
+node-api = { path = "../api" }
+node-consensus = { path = "../consensus" }
+node-primitives = { path = "../primitives" }
+substrate-bft = { path = "../../core/bft" }
+substrate-network = { path = "../../core/network" }
+substrate-primitives = { path = "../../core/primitives" }
+futures = "0.1"
+tokio = "0.1.7"
+log = "0.4"
+rhododendron = "0.3"

substrate/node/network/src/consensus.rs

@@ -0,0 +1,297 @@
+// 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/>.
+
+//! The "consensus" networking code built on top of the base network service.
+//! This fulfills the `node_consensus::Network` trait, providing a hook to be called
+//! each time consensus begins on a new chain head.
+
+use bft;
+use substrate_primitives::ed25519;
+use substrate_network::{self as net, generic_message as msg};
+use substrate_network::consensus_gossip::ConsensusMessage;
+use node_api::Api;
+use node_consensus::Network;
+use node_primitives::{Block, Hash, SessionKey};
+use rhododendron;
+
+use futures::prelude::*;
+use futures::sync::mpsc;
+
+use std::sync::Arc;
+
+use tokio::runtime::TaskExecutor;
+
+use super::NetworkService;
+
+/// Sink for output BFT messages.
+pub struct BftSink<E> {
+	network: Arc<NetworkService>,
+	parent_hash: Hash,
+	_marker: ::std::marker::PhantomData<E>,
+}
+
+impl<E> Sink for BftSink<E> {
+	type SinkItem = bft::Communication<Block>;
+	// TODO: replace this with the ! type when that's stabilized
+	type SinkError = E;
+
+	fn start_send(&mut self, message: bft::Communication<Block>)
+		-> ::futures::StartSend<bft::Communication<Block>, E>
+	{
+		let network_message = net::LocalizedBftMessage {
+			message: match message {
+				rhododendron::Communication::Consensus(c) => msg::BftMessage::Consensus(match c {
+					rhododendron::LocalizedMessage::Propose(proposal) => msg::SignedConsensusMessage::Propose(msg::SignedConsensusProposal {
+						round_number: proposal.round_number as u32,
+						proposal: proposal.proposal,
+						digest: proposal.digest,
+						sender: proposal.sender,
+						digest_signature: proposal.digest_signature.signature,
+						full_signature: proposal.full_signature.signature,
+					}),
+					rhododendron::LocalizedMessage::Vote(vote) => msg::SignedConsensusMessage::Vote(msg::SignedConsensusVote {
+						sender: vote.sender,
+						signature: vote.signature.signature,
+						vote: match vote.vote {
+							rhododendron::Vote::Prepare(r, h) => msg::ConsensusVote::Prepare(r as u32, h),
+							rhododendron::Vote::Commit(r, h) => msg::ConsensusVote::Commit(r as u32, h),
+							rhododendron::Vote::AdvanceRound(r) => msg::ConsensusVote::AdvanceRound(r as u32),
+						}
+					}),
+				}),
+				rhododendron::Communication::Auxiliary(justification) => {
+					let unchecked: bft::UncheckedJustification<_> = justification.uncheck().into();
+					msg::BftMessage::Auxiliary(unchecked.into())
+				}
+			},
+			parent_hash: self.parent_hash,
+		};
+		self.network.with_spec(
+			move |spec, ctx| spec.consensus_gossip.multicast_bft_message(ctx, network_message)
+		);
+		Ok(::futures::AsyncSink::Ready)
+	}
+
+	fn poll_complete(&mut self) -> ::futures::Poll<(), E> {
+		Ok(Async::Ready(()))
+	}
+}
+
+// check signature and authority validity of message.
+fn process_bft_message(
+	msg: msg::LocalizedBftMessage<Block, Hash>,
+	local_id: &SessionKey,
+	authorities: &[SessionKey]
+	) -> Result<Option<bft::Communication<Block>>, bft::Error>
+{
+	Ok(Some(match msg.message {
+		msg::BftMessage::Consensus(c) => rhododendron::Communication::Consensus(match c {
+			msg::SignedConsensusMessage::Propose(proposal) => rhododendron::LocalizedMessage::Propose({
+				if &proposal.sender == local_id { return Ok(None) }
+				let proposal = rhododendron::LocalizedProposal {
+					round_number: proposal.round_number as usize,
+					proposal: proposal.proposal,
+					digest: proposal.digest,
+					sender: proposal.sender,
+					digest_signature: ed25519::LocalizedSignature {
+						signature: proposal.digest_signature,
+						signer: ed25519::Public(proposal.sender.into()),
+					},
+					full_signature: ed25519::LocalizedSignature {
+						signature: proposal.full_signature,
+						signer: ed25519::Public(proposal.sender.into()),
+					}
+				};
+				bft::check_proposal(authorities, &msg.parent_hash, &proposal)?;
+
+				trace!(target: "bft", "importing proposal message for round {} from {}", proposal.round_number, Hash::from(proposal.sender.0));
+				proposal
+			}),
+			msg::SignedConsensusMessage::Vote(vote) => rhododendron::LocalizedMessage::Vote({
+				if &vote.sender == local_id { return Ok(None) }
+				let vote = rhododendron::LocalizedVote {
+					sender: vote.sender,
+					signature: ed25519::LocalizedSignature {
+						signature: vote.signature,
+						signer: ed25519::Public(vote.sender.0),
+					},
+					vote: match vote.vote {
+						msg::ConsensusVote::Prepare(r, h) => rhododendron::Vote::Prepare(r as usize, h),
+						msg::ConsensusVote::Commit(r, h) => rhododendron::Vote::Commit(r as usize, h),
+						msg::ConsensusVote::AdvanceRound(r) => rhododendron::Vote::AdvanceRound(r as usize),
+					}
+				};
+				bft::check_vote::<Block>(authorities, &msg.parent_hash, &vote)?;
+
+				trace!(target: "bft", "importing vote {:?} from {}", vote.vote, Hash::from(vote.sender.0));
+				vote
+			}),
+		}),
+		msg::BftMessage::Auxiliary(a) => {
+			let justification = bft::UncheckedJustification::from(a);
+			// TODO: get proper error
+			let justification: Result<_, bft::Error> = bft::check_prepare_justification::<Block>(authorities, msg.parent_hash, justification)
+				.map_err(|_| bft::ErrorKind::InvalidJustification.into());
+			rhododendron::Communication::Auxiliary(justification?)
+		},
+	}))
+}
+
+// task that processes all gossipped consensus messages,
+// checking signatures
+struct MessageProcessTask {
+	inner_stream: mpsc::UnboundedReceiver<ConsensusMessage<Block>>,
+	bft_messages: mpsc::UnboundedSender<bft::Communication<Block>>,
+	validators: Vec<SessionKey>,
+	local_id: SessionKey,
+}
+
+impl MessageProcessTask {
+	fn process_message(&self, msg: ConsensusMessage<Block>) -> Option<Async<()>> {
+		match msg {
+			ConsensusMessage::Bft(msg) => {
+				match process_bft_message(msg, &self.local_id, &self.validators[..]) {
+					Ok(Some(msg)) => {
+						if let Err(_) = self.bft_messages.unbounded_send(msg) {
+							// if the BFT receiving stream has ended then
+							// we should just bail.
+							trace!(target: "bft", "BFT message stream appears to have closed");
+							return Some(Async::Ready(()));
+						}
+					}
+					Ok(None) => {} // ignored local message
+					Err(e) => {
+						debug!("Message validation failed: {:?}", e);
+					}
+				}
+			}
+			ConsensusMessage::ChainSpecific(_, _) => {
+				panic!("ChainSpecific messages are not allowed by the top level message handler");
+			}
+		}
+
+		None
+	}
+}
+
+impl Future for MessageProcessTask {
+	type Item = ();
+	type Error = ();
+
+	fn poll(&mut self) -> Poll<(), ()> {
+		loop {
+			match self.inner_stream.poll() {
+				Ok(Async::Ready(Some(val))) => if let Some(async) = self.process_message(val) {
+					return Ok(async);
+				},
+				Ok(Async::Ready(None)) => return Ok(Async::Ready(())),
+				Ok(Async::NotReady) => return Ok(Async::NotReady),
+				Err(e) => {
+					debug!(target: "node-network", "Error getting consensus message: {:?}", e);
+					return Err(e);
+				},
+			}
+		}
+	}
+}
+
+/// Input stream from the consensus network.
+pub struct InputAdapter {
+	input: mpsc::UnboundedReceiver<bft::Communication<Block>>,
+}
+
+impl Stream for InputAdapter {
+	type Item = bft::Communication<Block>;
+	type Error = ::node_consensus::Error;
+
+	fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+		match self.input.poll() {
+			Err(_) | Ok(Async::Ready(None)) => Err(bft::InputStreamConcluded.into()),
+			Ok(x) => Ok(x)
+		}
+	}
+}
+
+/// Wrapper around the network service
+pub struct ConsensusNetwork<P> {
+	network: Arc<NetworkService>,
+	api: Arc<P>,
+}
+
+impl<P> ConsensusNetwork<P> {
+	/// Create a new consensus networking object.
+	pub fn new(network: Arc<NetworkService>, api: Arc<P>) -> Self {
+		ConsensusNetwork { network, api }
+	}
+}
+
+impl<P> Clone for ConsensusNetwork<P> {
+	fn clone(&self) -> Self {
+		ConsensusNetwork {
+			network: self.network.clone(),
+			api: self.api.clone(),
+		}
+	}
+}
+
+/// A long-lived network which can create parachain statement and BFT message routing processes on demand.
+impl<P: Api + Send + Sync + 'static> Network for ConsensusNetwork<P> {
+	/// The input stream of BFT messages. Should never logically conclude.
+	type Input = InputAdapter;
+	/// The output sink of BFT messages. Messages sent here should eventually pass to all
+	/// current validators.
+	type Output = BftSink<::node_consensus::Error>;
+
+	/// Get input and output streams of BFT messages.
+	fn communication_for(
+		&self, validators: &[SessionKey],
+		local_id: SessionKey,
+		parent_hash: Hash,
+		task_executor: TaskExecutor
+	) -> (Self::Input, Self::Output)
+	{
+		let sink = BftSink {
+			network: self.network.clone(),
+			parent_hash,
+			_marker: Default::default(),
+		};
+
+		let (bft_send, bft_recv) = mpsc::unbounded();
+
+		// spin up a task in the background that processes all incoming statements
+		// TODO: propagate statements on a timer?
+		let process_task = self.network.with_spec(|spec, _ctx| {
+			spec.new_consensus(parent_hash);
+			MessageProcessTask {
+				inner_stream: spec.consensus_gossip.messages_for(parent_hash),
+				bft_messages: bft_send,
+				validators: validators.to_vec(),
+				local_id,
+			}
+		});
+
+		match process_task {
+			Some(task) => task_executor.spawn(task),
+			None => warn!(target: "node-network", "Cannot process incoming messages: network appears to be down"),
+		}
+
+		(InputAdapter { input: bft_recv }, sink)
+	}
+}
+
+/// Error when the network appears to be down.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct NetworkDown;

substrate/node/network/src/lib.rs

@@ -0,0 +1,117 @@
+// 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/>.
+
+//! Substrate-specific network implementation.
+//!
+//! This manages gossip of consensus messages for BFT.
+
+#![warn(unused_extern_crates)]
+
+extern crate substrate_bft as bft;
+extern crate substrate_network;
+extern crate substrate_primitives;
+
+extern crate node_api;
+extern crate node_consensus;
+extern crate node_primitives;
+
+extern crate futures;
+extern crate tokio;
+extern crate rhododendron;
+
+#[macro_use]
+extern crate log;
+
+pub mod consensus;
+
+use node_primitives::{Block, Hash, Header};
+use substrate_network::{NodeIndex, Context, Severity};
+use substrate_network::consensus_gossip::ConsensusGossip;
+use substrate_network::{message, generic_message};
+use substrate_network::specialization::Specialization;
+use substrate_network::StatusMessage as GenericFullStatus;
+
+/// Demo protocol id.
+pub const PROTOCOL_ID: ::substrate_network::ProtocolId = *b"dot";
+
+type FullStatus = GenericFullStatus<Block>;
+
+/// Specialization of the network service for the node protocol.
+pub type NetworkService = ::substrate_network::Service<Block, Protocol, Hash>;
+
+
+/// Demo protocol attachment for substrate.
+pub struct Protocol {
+	consensus_gossip: ConsensusGossip<Block>,
+	live_consensus: Option<Hash>,
+}
+
+impl Protocol {
+	/// Instantiate a node protocol handler.
+	pub fn new() -> Self {
+		Protocol {
+			consensus_gossip: ConsensusGossip::new(),
+			live_consensus: None,
+		}
+	}
+
+	/// Note new consensus session.
+	fn new_consensus(&mut self, parent_hash: Hash) {
+		let old_consensus = self.live_consensus.take();
+		self.live_consensus = Some(parent_hash);
+		self.consensus_gossip.collect_garbage(old_consensus.as_ref());
+	}
+}
+
+impl Specialization<Block> for Protocol {
+	fn status(&self) -> Vec<u8> {
+		Vec::new()
+	}
+
+	fn on_connect(&mut self, ctx: &mut Context<Block>, who: NodeIndex, status: FullStatus) {
+		self.consensus_gossip.new_peer(ctx, who, status.roles);
+	}
+
+	fn on_disconnect(&mut self, ctx: &mut Context<Block>, who: NodeIndex) {
+		self.consensus_gossip.peer_disconnected(ctx, who);
+	}
+
+	fn on_message(&mut self, ctx: &mut Context<Block>, who: NodeIndex, message: message::Message<Block>) {
+		match message {
+			generic_message::Message::BftMessage(msg) => {
+				trace!(target: "node-network", "BFT message from {}: {:?}", who, msg);
+				// TODO: check signature here? what if relevant block is unknown?
+				self.consensus_gossip.on_bft_message(ctx, who, msg)
+			}
+			generic_message::Message::ChainSpecific(_) => {
+				trace!(target: "node-network", "Bad message from {}", who);
+				ctx.report_peer(who, Severity::Bad("Invalid node protocol message format"));
+			}
+			_ => {}
+		}
+	}
+
+	fn on_abort(&mut self) {
+		self.consensus_gossip.abort();
+	}
+
+	fn maintain_peers(&mut self, _ctx: &mut Context<Block>) {
+	}
+
+	fn on_block_imported(&mut self, _ctx: &mut Context<Block>, _hash: Hash, _header: &Header) {
+	}
+}
+

substrate/node/primitives/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "node-primitives"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+serde = { version = "1.0", default_features = false }
+serde_derive = { version = "1.0", optional = true }
+parity-codec = { path = "../../codec", default_features = false }
+parity-codec-derive = { path = "../../codec/derive", default_features = false }
+substrate-primitives = { path = "../../core/primitives", default_features = false }
+sr-std = { path = "../../core/sr-std", default_features = false }
+sr-primitives = { path = "../../core/sr-primitives", default_features = false }
+
+[dev-dependencies]
+substrate-serializer = { path = "../../core/serializer" }
+pretty_assertions = "0.4"
+
+[features]
+default = ["std"]
+std = [
+	"parity-codec-derive/std",
+	"parity-codec/std",
+	"substrate-primitives/std",
+	"sr-std/std",
+	"sr-primitives/std",
+	"serde_derive",
+	"serde/std",
+]

substrate/node/primitives/src/lib.rs

@@ -0,0 +1,94 @@
+// 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/>.
+
+//! Low-level types used throughout the Substrate code.
+
+#![warn(missing_docs)]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(alloc))]
+
+#[cfg(feature = "std")]
+extern crate serde;
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate serde_derive;
+
+#[macro_use]
+extern crate parity_codec_derive;
+
+extern crate sr_std as rstd;
+extern crate sr_primitives as runtime_primitives;
+extern crate substrate_primitives as primitives;
+extern crate parity_codec as codec;
+
+use rstd::prelude::*;
+use runtime_primitives::generic;
+#[cfg(feature = "std")]
+use primitives::bytes;
+use runtime_primitives::traits::BlakeTwo256;
+
+/// An index to a block.
+pub type BlockNumber = u64;
+
+/// Alias to Ed25519 pubkey that identifies an account on the chain. This will almost
+/// certainly continue to be the same as the substrate's `AuthorityId`.
+pub type AccountId = ::primitives::H256;
+
+/// The type for looking up accounts. We don't expect more than 4 billion of them, but you
+/// never know...
+pub type AccountIndex = u32;
+
+/// Balance of an account.
+pub type Balance = u64;
+
+/// The Ed25519 pub key of an session that belongs to an authority of the chain. This is
+/// exactly equivalent to what the substrate calls an "authority".
+pub type SessionKey = primitives::AuthorityId;
+
+/// Index of a transaction in the chain.
+pub type Index = u64;
+
+/// A hash of some data used by the chain.
+pub type Hash = primitives::H256;
+
+/// Alias to 512-bit hash when used in the context of a signature on the chain.
+pub type Signature = runtime_primitives::Ed25519Signature;
+
+/// A timestamp: seconds since the unix epoch.
+pub type Timestamp = u64;
+
+/// Header type.
+pub type Header = generic::Header<BlockNumber, BlakeTwo256, generic::DigestItem<()>>;
+/// Block type.
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+/// Block ID.
+pub type BlockId = generic::BlockId<Block>;
+
+/// Opaque, encoded, unchecked extrinsic.
+#[derive(PartialEq, Eq, Clone, Default, Encode, Decode)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct UncheckedExtrinsic(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+///
+/// Inherent data to include in a block.
+#[derive(Encode, Decode)]
+pub struct InherentData {
+	/// Current timestamp.
+	pub timestamp: Timestamp,
+	/// Indices of offline validators.
+	pub offline_indices: Vec<u32>,
+}

substrate/node/runtime/Cargo.toml

@@ -0,0 +1,61 @@
+[package]
+name = "node-runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+rustc-hex = "1.0"
+hex-literal = "0.1.0"
+log = { version = "0.3", optional = true }
+serde = { version = "1.0", default_features = false }
+serde_derive = { version = "1.0", optional = true }
+safe-mix = { version = "1.0", default_features = false}
+parity-codec = { path = "../../codec" }
+parity-codec-derive = { path = "../../codec/derive" }
+sr-std = { path = "../../core/sr-std" }
+sr-io = { path = "../../core/sr-io" }
+srml-support = { path = "../../srml/support" }
+substrate-primitives = { path = "../../core/primitives" }
+substrate-keyring = { path = "../../core/keyring" }
+srml-balances = { path = "../../srml/balances" }
+srml-consensus = { path = "../../srml/consensus" }
+srml-contract = { path = "../../srml/contract" }
+srml-council = { path = "../../srml/council" }
+srml-democracy = { path = "../../srml/democracy" }
+srml-executive = { path = "../../srml/executive" }
+sr-primitives = { path = "../../core/sr-primitives" }
+srml-session = { path = "../../srml/session" }
+srml-staking = { path = "../../srml/staking" }
+srml-system = { path = "../../srml/system" }
+srml-timestamp = { path = "../../srml/timestamp" }
+srml-treasury = { path = "../../srml/treasury" }
+sr-version = { path = "../../core/sr-version" }
+node-primitives = { path = "../primitives" }
+
+[features]
+default = ["std"]
+std = [
+	"parity-codec/std",
+	"substrate-primitives/std",
+	"sr-std/std",
+	"sr-io/std",
+	"srml-support/std",
+	"srml-balances/std",
+	"srml-consensus/std",
+	"srml-contract/std",
+	"srml-council/std",
+	"srml-democracy/std",
+	"srml-executive/std",
+	"sr-primitives/std",
+	"srml-session/std",
+	"srml-staking/std",
+	"srml-system/std",
+	"srml-timestamp/std",
+	"srml-treasury/std",
+	"sr-version/std",
+	"node-primitives/std",
+	"serde_derive",
+	"serde/std",
+	"log",
+	"safe-mix/std"
+]

substrate/node/runtime/src/checked_block.rs

@@ -0,0 +1,94 @@
+// 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/>.
+
+//! Typesafe block interaction.
+
+use super::{Call, Block, TIMESTAMP_SET_POSITION, NOTE_OFFLINE_POSITION};
+use timestamp::Call as TimestampCall;
+use consensus::Call as ConsensusCall;
+
+/// Provides a type-safe wrapper around a structurally valid block.
+pub struct CheckedBlock {
+	inner: Block,
+	file_line: Option<(&'static str, u32)>,
+}
+
+impl CheckedBlock {
+	/// Create a new checked block. Fails if the block is not structurally valid.
+	pub fn new(block: Block) -> Result<Self, Block> {
+		let has_timestamp = block.extrinsics.get(TIMESTAMP_SET_POSITION as usize).map_or(false, |xt| {
+			!xt.is_signed() && match xt.function {
+				Call::Timestamp(TimestampCall::set(_)) => true,
+				_ => false,
+			}
+		});
+
+		if !has_timestamp { return Err(block) }
+
+		Ok(CheckedBlock {
+			inner: block,
+			file_line: None,
+		})
+	}
+
+	// Creates a new checked block, asserting that it is valid.
+	#[doc(hidden)]
+	pub fn new_unchecked(block: Block, file: &'static str, line: u32) -> Self {
+		CheckedBlock {
+			inner: block,
+			file_line: Some((file, line)),
+		}
+	}
+
+	/// Extract the timestamp from the block.
+	pub fn timestamp(&self) -> ::node_primitives::Timestamp {
+		let x = self.inner.extrinsics.get(TIMESTAMP_SET_POSITION as usize).and_then(|xt| match xt.function {
+			Call::Timestamp(TimestampCall::set(x)) => Some(x),
+			_ => None
+		});
+
+		match x {
+			Some(x) => x,
+			None => panic!("Invalid block asserted at {:?}", self.file_line),
+		}
+	}
+
+	/// Extract the noted missed proposal validator indices (if any) from the block.
+	pub fn noted_offline(&self) -> &[u32] {
+		self.inner.extrinsics.get(NOTE_OFFLINE_POSITION as usize).and_then(|xt| match xt.function {
+			Call::Consensus(ConsensusCall::note_offline(ref x)) => Some(&x[..]),
+			_ => None,
+		}).unwrap_or(&[])
+	}
+
+	/// Convert into inner block.
+	pub fn into_inner(self) -> Block { self.inner }
+}
+
+impl ::std::ops::Deref for CheckedBlock {
+	type Target = Block;
+
+	fn deref(&self) -> &Block { &self.inner }
+}
+
+/// Assert that a block is structurally valid. May lead to panic in the future
+/// in case it isn't.
+#[macro_export]
+macro_rules! assert_node_block {
+	($block: expr) => {
+		$crate::CheckedBlock::new_unchecked($block, file!(), line!())
+	}
+}

substrate/node/runtime/src/lib.rs

@@ -0,0 +1,368 @@
+// 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/>.
+
+//! The Substrate runtime. This can be compiled with ``#[no_std]`, ready for Wasm.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[macro_use]
+extern crate sr_io as runtime_io;
+
+#[macro_use]
+extern crate srml_support;
+
+#[macro_use]
+extern crate sr_primitives as runtime_primitives;
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate serde_derive;
+
+#[cfg(feature = "std")]
+extern crate serde;
+
+extern crate parity_codec as codec;
+extern crate substrate_primitives;
+
+#[macro_use]
+extern crate parity_codec_derive;
+
+#[cfg_attr(not(feature = "std"), macro_use)]
+extern crate sr_std as rstd;
+extern crate srml_balances as balances;
+extern crate srml_consensus as consensus;
+extern crate srml_contract as contract;
+extern crate srml_council as council;
+extern crate srml_democracy as democracy;
+extern crate srml_executive as executive;
+extern crate srml_session as session;
+extern crate srml_staking as staking;
+extern crate srml_system as system;
+extern crate srml_timestamp as timestamp;
+extern crate srml_treasury as treasury;
+#[macro_use]
+extern crate sr_version as version;
+extern crate node_primitives;
+
+#[cfg(feature = "std")]
+mod checked_block;
+
+use rstd::prelude::*;
+use substrate_primitives::u32_trait::{_2, _4};
+use codec::{Encode, Decode, Input};
+use node_primitives::{AccountId, AccountIndex, Balance, BlockNumber, Hash, Index, SessionKey, Signature, InherentData};
+use runtime_primitives::generic;
+use runtime_primitives::traits::{Convert, BlakeTwo256, DigestItem};
+use version::RuntimeVersion;
+use council::{motions as council_motions, voting as council_voting};
+
+#[cfg(any(feature = "std", test))]
+pub use runtime_primitives::BuildStorage;
+pub use consensus::Call as ConsensusCall;
+pub use timestamp::Call as TimestampCall;
+pub use runtime_primitives::Permill;
+#[cfg(any(feature = "std", test))]
+pub use checked_block::CheckedBlock;
+
+const TIMESTAMP_SET_POSITION: u32 = 0;
+const NOTE_OFFLINE_POSITION: u32 = 1;
+
+// Workaround for https://github.com/rust-lang/rust/issues/26925 . Remove when sorted.
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+/// Runtime type used to collate and parameterize the various modules.
+pub struct Runtime;
+
+/// Runtime version.
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: ver_str!("node"),
+	impl_name: ver_str!("substrate-node"),
+	authoring_version: 1,
+	spec_version: 1,
+	impl_version: 0,
+};
+
+impl system::Trait for Runtime {
+	type Origin = Origin;
+	type Index = Index;
+	type BlockNumber = BlockNumber;
+	type Hash = Hash;
+	type Hashing = BlakeTwo256;
+	type Digest = generic::Digest<Log>;
+	type AccountId = AccountId;
+	type Header = generic::Header<BlockNumber, BlakeTwo256, Log>;
+	type Event = Event;
+}
+
+/// System module for this concrete runtime.
+pub type System = system::Module<Runtime>;
+
+impl balances::Trait for Runtime {
+	type Balance = Balance;
+	type AccountIndex = AccountIndex;
+	type OnFreeBalanceZero = (Staking, Contract);
+	type EnsureAccountLiquid = Staking;
+	type Event = Event;
+}
+
+/// Staking module for this concrete runtime.
+pub type Balances = balances::Module<Runtime>;
+
+impl consensus::Trait for Runtime {
+	const NOTE_OFFLINE_POSITION: u32 = NOTE_OFFLINE_POSITION;
+	type Log = Log;
+	type SessionKey = SessionKey;
+	type OnOfflineValidator = Staking;
+}
+
+/// Consensus module for this concrete runtime.
+pub type Consensus = consensus::Module<Runtime>;
+
+impl timestamp::Trait for Runtime {
+	const TIMESTAMP_SET_POSITION: u32 = TIMESTAMP_SET_POSITION;
+	type Moment = u64;
+}
+
+/// Timestamp module for this concrete runtime.
+pub type Timestamp = timestamp::Module<Runtime>;
+
+/// Session key conversion.
+pub struct SessionKeyConversion;
+impl Convert<AccountId, SessionKey> for SessionKeyConversion {
+	fn convert(a: AccountId) -> SessionKey {
+		a.0.into()
+	}
+}
+
+impl session::Trait for Runtime {
+	type ConvertAccountIdToSessionKey = SessionKeyConversion;
+	type OnSessionChange = Staking;
+	type Event = Event;
+}
+
+/// Session module for this concrete runtime.
+pub type Session = session::Module<Runtime>;
+
+impl staking::Trait for Runtime {
+	type OnRewardMinted = Treasury;
+	type Event = Event;
+}
+
+/// Staking module for this concrete runtime.
+pub type Staking = staking::Module<Runtime>;
+
+impl democracy::Trait for Runtime {
+	type Proposal = Call;
+	type Event = Event;
+}
+
+/// Democracy module for this concrete runtime.
+pub type Democracy = democracy::Module<Runtime>;
+
+impl council::Trait for Runtime {
+	type Event = Event;
+}
+
+/// Council module for this concrete runtime.
+pub type Council = council::Module<Runtime>;
+
+impl council::voting::Trait for Runtime {
+	type Event = Event;
+}
+
+/// Council voting module for this concrete runtime.
+pub type CouncilVoting = council::voting::Module<Runtime>;
+
+impl council::motions::Trait for Runtime {
+	type Origin = Origin;
+	type Proposal = Call;
+	type Event = Event;
+}
+
+/// Council motions module for this concrete runtime.
+pub type CouncilMotions = council_motions::Module<Runtime>;
+
+impl treasury::Trait for Runtime {
+	type ApproveOrigin = council_motions::EnsureMembers<_4>;
+	type RejectOrigin = council_motions::EnsureMembers<_2>;
+	type Event = Event;
+}
+
+/// Treasury module for this concrete runtime.
+pub type Treasury = treasury::Module<Runtime>;
+
+impl contract::Trait for Runtime {
+	type Gas = u64;
+	type DetermineContractAddress = contract::SimpleAddressDeterminator<Runtime>;
+}
+
+/// Contract module for this concrete runtime.
+pub type Contract = contract::Module<Runtime>;
+
+impl_outer_event! {
+	pub enum Event for Runtime {
+		//consensus,
+		balances,
+		//timetstamp,
+		session,
+		staking,
+		democracy,
+		council,
+		council_voting,
+		council_motions,
+		treasury
+	}
+}
+
+impl_outer_log! {
+	pub enum Log(InternalLog: DigestItem<SessionKey>) for Runtime {
+		consensus(AuthoritiesChange)
+	}
+}
+
+impl_outer_origin! {
+	pub enum Origin for Runtime {
+		council_motions
+	}
+}
+
+impl_outer_dispatch! {
+	pub enum Call where origin: Origin {
+		Consensus,
+		Balances,
+		Timestamp,
+		Session,
+		Staking,
+		Democracy,
+		Council,
+		CouncilVoting,
+		CouncilMotions,
+		Treasury,
+		Contract,
+	}
+}
+
+impl_outer_config! {
+	pub struct GenesisConfig for Runtime {
+		SystemConfig => system,
+		ConsensusConfig => consensus,
+		ContractConfig => contract,
+		BalancesConfig => balances,
+		TimestampConfig => timestamp,
+		SessionConfig => session,
+		StakingConfig => staking,
+		DemocracyConfig => democracy,
+		CouncilConfig => council,
+		TreasuryConfig => treasury,
+	}
+}
+
+type AllModules = (
+	Consensus,
+	Balances,
+	Timestamp,
+	Session,
+	Staking,
+	Democracy,
+	Council,
+	CouncilVoting,
+	CouncilMotions,
+	Treasury,
+	Contract,
+);
+
+impl_json_metadata!(
+	for Runtime with modules
+		system::Module with Storage,
+		consensus::Module with Storage,
+		balances::Module with Storage,
+		timestamp::Module with Storage,
+		session::Module with Storage,
+		staking::Module with Storage,
+		democracy::Module with Storage,
+		council::Module with Storage,
+		council_voting::Module with Storage,
+		council_motions::Module with Storage,
+		treasury::Module with Storage,
+		contract::Module with Storage,
+);
+
+impl DigestItem for Log {
+	type AuthorityId = SessionKey;
+
+	fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]> {
+		match self.0 {
+			InternalLog::consensus(ref item) => item.as_authorities_change(),
+		}
+	}
+}
+
+/// The address format for describing accounts.
+pub use balances::address::Address as RawAddress;
+/// The address format for describing accounts.
+pub type Address = balances::Address<Runtime>;
+/// Block header type as expected by this runtime.
+pub type Header = generic::Header<BlockNumber, BlakeTwo256, Log>;
+/// Block type as expected by this runtime.
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+/// BlockId type as expected by this runtime.
+pub type BlockId = generic::BlockId<Block>;
+/// Unchecked extrinsic type as expected by this runtime.
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Index, Call, Signature>;
+/// Extrinsic type that has already been checked.
+pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Index, Call>;
+/// Executive: handles dispatch to the various modules.
+pub type Executive = executive::Executive<Runtime, Block, Balances, Balances, AllModules>;
+
+pub mod api {
+	impl_stubs!(
+		version => |()| super::VERSION,
+		json_metadata => |()| super::Runtime::json_metadata(),
+		authorities => |()| super::Consensus::authorities(),
+		initialise_block => |header| super::Executive::initialise_block(&header),
+		apply_extrinsic => |extrinsic| super::Executive::apply_extrinsic(extrinsic),
+		execute_block => |block| super::Executive::execute_block(block),
+		finalise_block => |()| super::Executive::finalise_block(),
+		inherent_extrinsics => |(inherent, spec_version)| super::inherent_extrinsics(inherent, spec_version),
+		validator_count => |()| super::Session::validator_count(),
+		validators => |()| super::Session::validators(),
+		timestamp => |()| super::Timestamp::get(),
+		random_seed => |()| super::System::random_seed(),
+		account_nonce => |account| super::System::account_nonce(&account),
+		lookup_address => |address| super::Balances::lookup_address(address)
+	);
+}
+
+/// Produces the list of inherent extrinsics.
+fn inherent_extrinsics(data: InherentData, _spec_version: u32) -> Vec<UncheckedExtrinsic> {
+	let make_inherent = |function| UncheckedExtrinsic {
+		signature: Default::default(),
+		function,
+		index: 0,
+	};
+
+	let mut inherent = vec![
+		make_inherent(Call::Timestamp(TimestampCall::set(data.timestamp))),
+	];
+
+	if !data.offline_indices.is_empty() {
+		inherent.push(make_inherent(
+				Call::Consensus(ConsensusCall::note_offline(data.offline_indices))
+		));
+	}
+
+	inherent
+}

substrate/node/runtime/wasm/Cargo.toml

@@ -0,0 +1,63 @@
+[package]
+name = "node-runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+integer-sqrt = { git = "https://github.com/paritytech/integer-sqrt-rs.git", branch = "master" }
+safe-mix = { version = "1.0", default_features = false}
+parity-codec-derive = { path = "../../../codec/derive" }
+parity-codec = { path = "../../../codec", default-features = false }
+substrate-primitives = { path = "../../../core/primitives", default-features = false }
+sr-std = { path = "../../../core/sr-std", default-features = false }
+sr-io = { path = "../../../core/sr-io", default-features = false }
+srml-support = { path = "../../../srml/support", default-features = false }
+srml-balances = { path = "../../../srml/balances", default-features = false }
+srml-consensus = { path = "../../../srml/consensus", default-features = false }
+srml-contract = { path = "../../../srml/contract", default-features = false }
+srml-council = { path = "../../../srml/council", default-features = false }
+srml-democracy = { path = "../../../srml/democracy", default-features = false }
+srml-executive = { path = "../../../srml/executive", default-features = false }
+sr-primitives = { path = "../../../core/sr-primitives", default-features = false }
+srml-session = { path = "../../../srml/session", default-features = false }
+srml-staking = { path = "../../../srml/staking", default-features = false }
+srml-system = { path = "../../../srml/system", default-features = false }
+srml-timestamp = { path = "../../../srml/timestamp", default-features = false }
+srml-treasury = { path = "../../../srml/treasury", default-features = false }
+sr-version = { path = "../../../core/sr-version", default-features = false }
+node-primitives = { path = "../../primitives", default-features = false }
+
+[features]
+default = []
+std = [
+	"safe-mix/std",
+	"parity-codec/std",
+	"substrate-primitives/std",
+	"sr-std/std",
+	"sr-io/std",
+	"srml-support/std",
+	"srml-balances/std",
+	"srml-consensus/std",
+	"srml-contract/std",
+	"srml-council/std",
+	"srml-democracy/std",
+	"srml-executive/std",
+	"sr-primitives/std",
+	"srml-session/std",
+	"srml-staking/std",
+	"srml-system/std",
+	"srml-timestamp/std",
+	"srml-treasury/std",
+	"sr-version/std",
+	"node-primitives/std",
+]
+
+[profile.release]
+panic = "abort"
+lto = true
+
+[workspace]
+members = []

substrate/node/runtime/wasm/build.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -e
+
+cargo +nightly build --target=wasm32-unknown-unknown --release
+for i in node_runtime
+do
+	wasm-gc target/wasm32-unknown-unknown/release/$i.wasm target/wasm32-unknown-unknown/release/$i.compact.wasm
+done

substrate/node/runtime/wasm/src

@@ -0,0 +1 @@
+../src

substrate/node/service/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "node-service"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+parking_lot = "0.4"
+error-chain = "0.12"
+lazy_static = "1.0"
+log = "0.3"
+slog = "^2"
+tokio = "0.1.7"
+hex-literal = "0.1"
+node-api = { path = "../api" }
+node-primitives = { path = "../primitives" }
+node-runtime = { path = "../runtime" }
+node-executor = { path = "../executor" }
+node-consensus = { path = "../consensus" }
+node-network = { path = "../network" }
+node-transaction-pool = { path = "../transaction-pool" }
+sr-io = { path = "../../core/sr-io" }
+substrate-primitives = { path = "../../core/primitives" }
+substrate-network = { path = "../../core/network" }
+substrate-client = { path = "../../core/client" }
+substrate-service = { path = "../../core/service" }
+substrate-telemetry = { path = "../../core/telemetry" }

substrate/node/service/src/chain_spec.rs

@@ -0,0 +1,226 @@
+// 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/>.
+
+//! Substrate chain configurations.
+
+use primitives::{AuthorityId, ed25519};
+use node_runtime::{GenesisConfig, ConsensusConfig, CouncilConfig, DemocracyConfig,
+	SessionConfig, StakingConfig, TimestampConfig, BalancesConfig, TreasuryConfig,
+	ContractConfig, Permill};
+use service::ChainSpec;
+
+const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/";
+
+pub fn testnet_config() -> Result<ChainSpec<GenesisConfig>, String> {
+	//ChainSpec::from_embedded(include_bytes!("../res/node.json"))
+	Ok(staging_testnet_config())
+}
+
+fn staging_testnet_config_genesis() -> GenesisConfig {
+	let initial_authorities = vec![
+		hex!["82c39b31a2b79a90f8e66e7a77fdb85a4ed5517f2ae39f6a80565e8ecae85cf5"].into(),
+		hex!["4de37a07567ebcbf8c64568428a835269a566723687058e017b6d69db00a77e7"].into(),
+		hex!["063d7787ebca768b7445dfebe7d62cbb1625ff4dba288ea34488da266dd6dca5"].into(),
+		hex!["8101764f45778d4980dadaceee6e8af2517d3ab91ac9bec9cd1714fa5994081c"].into(),
+	];
+	let endowed_accounts = vec![
+		hex!["f295940fa750df68a686fcf4abd4111c8a9c5a5a5a83c4c8639c451a94a7adfd"].into(),
+	];
+	GenesisConfig {
+		consensus: Some(ConsensusConfig {
+			code: include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/node_runtime.compact.wasm").to_vec(),	// TODO change
+			authorities: initial_authorities.clone(),
+		}),
+		system: None,
+		balances: Some(BalancesConfig {
+			transaction_base_fee: 100,
+			transaction_byte_fee: 1,
+			existential_deposit: 500,
+			transfer_fee: 0,
+			creation_fee: 0,
+			reclaim_rebate: 0,
+			balances: endowed_accounts.iter().map(|&k|(k, 1u64 << 60)).collect(),
+		}),
+		session: Some(SessionConfig {
+			validators: initial_authorities.iter().cloned().map(Into::into).collect(),
+			session_length: 60,	// that's 5 minutes per session.
+		}),
+		staking: Some(StakingConfig {
+			current_era: 0,
+			intentions: initial_authorities.iter().cloned().map(Into::into).collect(),
+			offline_slash: 10000,
+			session_reward: 100,
+			validator_count: 12,
+			sessions_per_era: 12,	// 1 hour per era
+			bonding_duration: 24 * 60 * 12,	// 1 day per bond.
+			offline_slash_grace: 4,
+			minimum_validator_count: 4,
+		}),
+		democracy: Some(DemocracyConfig {
+			launch_period: 12 * 60 * 24,	// 1 day per public referendum
+			voting_period: 12 * 60 * 24 * 3,	// 3 days to discuss & vote on an active referendum
+			minimum_deposit: 5000,	// 12000 as the minimum deposit for a referendum
+		}),
+		council: Some(CouncilConfig {
+			active_council: vec![],
+			candidacy_bond: 5000,	// 5000 to become a council candidate
+			voter_bond: 1000,		// 1000 down to vote for a candidate
+			present_slash_per_voter: 1,	// slash by 1 per voter for an invalid presentation.
+			carry_count: 6,		// carry over the 6 runners-up to the next council election
+			presentation_duration: 12 * 60 * 24,	// one day for presenting winners.
+			approval_voting_period: 12 * 60 * 24 * 2,	// two days period between possible council elections.
+			term_duration: 12 * 60 * 24 * 24,	// 24 day term duration for the council.
+			desired_seats: 0, // start with no council: we'll raise this once the stake has been dispersed a bit.
+			inactive_grace_period: 1,	// one addition vote should go by before an inactive voter can be reaped.
+
+			cooloff_period: 12 * 60 * 24 * 4, // 4 day cooling off period if council member vetoes a proposal.
+			voting_period: 12 * 60 * 24, // 1 day voting period for council members.
+		}),
+		timestamp: Some(TimestampConfig {
+			period: 5,					// 5 second block time.
+		}),
+		treasury: Some(TreasuryConfig {
+			proposal_bond: Permill::from_percent(5),
+			proposal_bond_minimum: 1_000_000,
+			spend_period: 12 * 60 * 24,
+			burn: Permill::from_percent(50),
+		}),
+		contract: Some(ContractConfig {
+			contract_fee: 21,
+			call_base_fee: 135,
+			create_base_fee: 175,
+			gas_price: 1,
+			max_depth: 1024,
+			block_gas_limit: 10_000_000,
+		}),
+	}
+}
+
+/// Staging testnet config.
+pub fn staging_testnet_config() -> ChainSpec<GenesisConfig> {
+	let boot_nodes = vec![];
+	ChainSpec::from_genesis(
+		"Staging Testnet",
+		"staging_testnet",
+		staging_testnet_config_genesis,
+		boot_nodes,
+		Some(STAGING_TELEMETRY_URL.into()),
+	)
+}
+
+fn testnet_genesis(initial_authorities: Vec<AuthorityId>) -> GenesisConfig {
+	let endowed_accounts = vec![
+		ed25519::Pair::from_seed(b"Alice                           ").public().0.into(),
+		ed25519::Pair::from_seed(b"Bob                             ").public().0.into(),
+		ed25519::Pair::from_seed(b"Charlie                         ").public().0.into(),
+		ed25519::Pair::from_seed(b"Dave                            ").public().0.into(),
+		ed25519::Pair::from_seed(b"Eve                             ").public().0.into(),
+		ed25519::Pair::from_seed(b"Ferdie                          ").public().0.into(),
+	];
+	GenesisConfig {
+		consensus: Some(ConsensusConfig {
+			code: include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/node_runtime.compact.wasm").to_vec(),
+			authorities: initial_authorities.clone(),
+		}),
+		system: None,
+		balances: Some(BalancesConfig {
+			transaction_base_fee: 1,
+			transaction_byte_fee: 0,
+			existential_deposit: 500,
+			transfer_fee: 0,
+			creation_fee: 0,
+			reclaim_rebate: 0,
+			balances: endowed_accounts.iter().map(|&k|(k, (1u64 << 60))).collect(),
+		}),
+		session: Some(SessionConfig {
+			validators: initial_authorities.iter().cloned().map(Into::into).collect(),
+			session_length: 10,
+		}),
+		staking: Some(StakingConfig {
+			current_era: 0,
+			intentions: initial_authorities.iter().cloned().map(Into::into).collect(),
+			minimum_validator_count: 1,
+			validator_count: 2,
+			sessions_per_era: 5,
+			bonding_duration: 2 * 60 * 12,
+			offline_slash: 0,
+			session_reward: 0,
+			offline_slash_grace: 0,
+		}),
+		democracy: Some(DemocracyConfig {
+			launch_period: 9,
+			voting_period: 18,
+			minimum_deposit: 10,
+		}),
+		council: Some(CouncilConfig {
+			active_council: endowed_accounts.iter()
+				.filter(|a| initial_authorities.iter().find(|&b| a.0 == b.0).is_none())
+				.map(|a| (a.clone(), 1000000)).collect(),
+			candidacy_bond: 10,
+			voter_bond: 2,
+			present_slash_per_voter: 1,
+			carry_count: 4,
+			presentation_duration: 10,
+			approval_voting_period: 20,
+			term_duration: 1000000,
+			desired_seats: (endowed_accounts.len() - initial_authorities.len()) as u32,
+			inactive_grace_period: 1,
+
+			cooloff_period: 75,
+			voting_period: 20,
+		}),
+		timestamp: Some(TimestampConfig {
+			period: 5,					// 5 second block time.
+		}),
+		treasury: Some(TreasuryConfig {
+			proposal_bond: Permill::from_percent(5),
+			proposal_bond_minimum: 1_000_000,
+			spend_period: 12 * 60 * 24,
+			burn: Permill::from_percent(50),
+		}),
+		contract: Some(ContractConfig {
+			contract_fee: 21,
+			call_base_fee: 135,
+			create_base_fee: 175,
+			gas_price: 1,
+			max_depth: 1024,
+			block_gas_limit: 10_000_000,
+		}),
+	}
+}
+
+fn development_config_genesis() -> GenesisConfig {
+	testnet_genesis(vec![
+		ed25519::Pair::from_seed(b"Alice                           ").public().into(),
+	])
+}
+
+/// Development config (single validator Alice)
+pub fn development_config() -> ChainSpec<GenesisConfig> {
+	ChainSpec::from_genesis("Development", "development", development_config_genesis, vec![], None)
+}
+
+fn local_testnet_genesis() -> GenesisConfig {
+	testnet_genesis(vec![
+		ed25519::Pair::from_seed(b"Alice                           ").public().into(),
+		ed25519::Pair::from_seed(b"Bob                             ").public().into(),
+	])
+}
+
+/// Local testnet config (multivalidator Alice + Bob)
+pub fn local_testnet_config() -> ChainSpec<GenesisConfig> {
+	ChainSpec::from_genesis("Local Testnet", "local_testnet", local_testnet_genesis, vec![], None)
+}

substrate/node/service/src/lib.rs

@@ -0,0 +1,213 @@
+// 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/>.
+
+#![warn(unused_extern_crates)]
+
+//! Substrate service. Specialized wrapper over substrate service.
+
+extern crate node_api;
+extern crate node_primitives;
+extern crate node_runtime;
+extern crate node_executor;
+extern crate node_network;
+extern crate node_transaction_pool as transaction_pool;
+extern crate node_consensus as consensus;
+extern crate substrate_primitives as primitives;
+extern crate substrate_network as network;
+extern crate substrate_client as client;
+extern crate substrate_service as service;
+extern crate tokio;
+
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate hex_literal;
+
+pub mod chain_spec;
+
+use std::sync::Arc;
+
+use transaction_pool::TransactionPool;
+use node_api::Api;
+use node_primitives::{Block, Hash};
+use node_runtime::GenesisConfig;
+use client::Client;
+use node_network::{Protocol as DemoProtocol, consensus::ConsensusNetwork};
+use tokio::runtime::TaskExecutor;
+use service::FactoryFullConfiguration;
+use primitives::{Blake2Hasher, RlpCodec};
+
+pub use service::{Roles, PruningMode, ExtrinsicPoolOptions,
+	ErrorKind, Error, ComponentBlock, LightComponents, FullComponents};
+pub use client::ExecutionStrategy;
+
+/// Specialised `ChainSpec`.
+pub type ChainSpec = service::ChainSpec<GenesisConfig>;
+/// Client type for specialised `Components`.
+pub type ComponentClient<C> = Client<<C as Components>::Backend, <C as Components>::Executor, Block>;
+pub type NetworkService = network::Service<Block, <Factory as service::ServiceFactory>::NetworkProtocol, Hash>;
+
+/// A collection of type to generalise specific components over full / light client.
+pub trait Components: service::Components {
+	/// Demo API.
+	type Api: 'static + Api + Send + Sync;
+	/// Client backend.
+	type Backend: 'static + client::backend::Backend<Block, Blake2Hasher, RlpCodec>;
+	/// Client executor.
+	type Executor: 'static + client::CallExecutor<Block, Blake2Hasher, RlpCodec> + Send + Sync;
+}
+
+impl Components for service::LightComponents<Factory> {
+	type Api = service::LightClient<Factory>;
+	type Executor = service::LightExecutor<Factory>;
+	type Backend = service::LightBackend<Factory>;
+}
+
+impl Components for service::FullComponents<Factory> {
+	type Api = service::FullClient<Factory>;
+	type Executor = service::FullExecutor<Factory>;
+	type Backend = service::FullBackend<Factory>;
+}
+
+/// All configuration for the node.
+pub type Configuration = FactoryFullConfiguration<Factory>;
+
+/// Demo-specific configuration.
+#[derive(Default)]
+pub struct CustomConfiguration;
+
+/// Config for the substrate service.
+pub struct Factory;
+
+impl service::ServiceFactory for Factory {
+	type Block = Block;
+	type ExtrinsicHash = Hash;
+	type NetworkProtocol = DemoProtocol;
+	type RuntimeDispatch = node_executor::Executor;
+	type FullExtrinsicPoolApi = transaction_pool::ChainApi<service::FullClient<Self>>;
+	type LightExtrinsicPoolApi = transaction_pool::ChainApi<service::LightClient<Self>>;
+	type Genesis = GenesisConfig;
+	type Configuration = CustomConfiguration;
+
+	const NETWORK_PROTOCOL_ID: network::ProtocolId = ::node_network::PROTOCOL_ID;
+
+	fn build_full_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<service::FullClient<Self>>)
+		-> Result<TransactionPool<service::FullClient<Self>>, Error>
+	{
+		Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
+	}
+
+	fn build_light_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<service::LightClient<Self>>)
+		-> Result<TransactionPool<service::LightClient<Self>>, Error>
+	{
+		Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
+	}
+
+	fn build_network_protocol(_config: &Configuration)
+		-> Result<DemoProtocol, Error>
+	{
+		Ok(DemoProtocol::new())
+	}
+}
+
+/// Demo service.
+pub struct Service<C: Components> {
+	inner: service::Service<C>,
+	client: Arc<ComponentClient<C>>,
+	network: Arc<NetworkService>,
+	api: Arc<<C as Components>::Api>,
+	_consensus: Option<consensus::Service>,
+}
+
+impl <C: Components> Service<C> {
+	pub fn client(&self) -> Arc<ComponentClient<C>> {
+		self.client.clone()
+	}
+
+	pub fn network(&self) -> Arc<NetworkService> {
+		self.network.clone()
+	}
+
+	pub fn api(&self) -> Arc<<C as Components>::Api> {
+		self.api.clone()
+	}
+}
+
+/// Creates light client and register protocol with the network service
+pub fn new_light(config: Configuration, executor: TaskExecutor)
+	-> Result<Service<LightComponents<Factory>>, Error>
+{
+	let service = service::Service::<LightComponents<Factory>>::new(config, executor.clone())?;
+	let api = service.client();
+	Ok(Service {
+		client: service.client(),
+		network: service.network(),
+		api: api,
+		inner: service,
+		_consensus: None,
+	})
+}
+
+/// Creates full client and register protocol with the network service
+pub fn new_full(config: Configuration, executor: TaskExecutor)
+	-> Result<Service<FullComponents<Factory>>, Error>
+{
+	let is_validator = (config.roles & Roles::AUTHORITY) == Roles::AUTHORITY;
+	let service = service::Service::<FullComponents<Factory>>::new(config, executor.clone())?;
+	// Spin consensus service if configured
+	let consensus = if is_validator {
+		// Load the first available key
+		let key = service.keystore().load(&service.keystore().contents()?[0], "")?;
+		info!("Using authority key {}", key.public());
+
+		let client = service.client();
+
+		let consensus_net = ConsensusNetwork::new(service.network(), client.clone());
+		Some(consensus::Service::new(
+			client.clone(),
+			client.clone(),
+			consensus_net,
+			service.extrinsic_pool(),
+			executor,
+			key,
+		))
+	} else {
+		None
+	};
+
+	Ok(Service {
+		client: service.client(),
+		network: service.network(),
+		api: service.client(),
+		inner: service,
+		_consensus: consensus,
+	})
+}
+
+/// Creates bare client without any networking.
+pub fn new_client(config: Configuration)
+	-> Result<Arc<service::ComponentClient<FullComponents<Factory>>>, Error>
+{
+	service::new_client::<Factory>(config)
+}
+
+impl<C: Components> ::std::ops::Deref for Service<C> {
+	type Target = service::Service<C>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.inner
+	}
+}

substrate/node/src/main.rs

@@ -0,0 +1,69 @@
+// 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/>.
+
+//! Substrate CLI
+
+#![warn(missing_docs)]
+
+extern crate node_cli as cli;
+extern crate ctrlc;
+extern crate futures;
+
+#[macro_use]
+extern crate error_chain;
+
+use cli::VersionInfo;
+use futures::sync::oneshot;
+use futures::{future, Future};
+
+use std::cell::RefCell;
+
+mod vergen {
+	#![allow(unused)]
+	include!(concat!(env!("OUT_DIR"), "/version.rs"));
+}
+
+// handles ctrl-c
+struct Exit;
+impl cli::IntoExit for Exit {
+	type Exit = future::MapErr<oneshot::Receiver<()>, fn(oneshot::Canceled) -> ()>;
+	fn into_exit(self) -> Self::Exit {
+		// can't use signal directly here because CtrlC takes only `Fn`.
+		let (exit_send, exit) = oneshot::channel();
+
+		let exit_send_cell = RefCell::new(Some(exit_send));
+		ctrlc::set_handler(move || {
+			if let Some(exit_send) = exit_send_cell.try_borrow_mut().expect("signal handler not reentrant; qed").take() {
+				exit_send.send(()).expect("Error sending exit notification");
+			}
+		}).expect("Error setting Ctrl-C handler");
+
+		exit.map_err(drop)
+	}
+}
+
+quick_main!(run);
+
+fn run() -> cli::error::Result<()> {
+	let version = VersionInfo {
+		commit: vergen::short_sha(),
+		version: env!("CARGO_PKG_VERSION"),
+		executable_name: "substrate",
+		author: "Parity Team <admin@parity.io>",
+		description: "Generic substrate node",
+	};
+	cli::run(::std::env::args(), Exit, version)
+}

substrate/node/transaction-pool/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "node-transaction-pool"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+log = "0.3.0"
+error-chain = "0.12"
+parking_lot = "0.4"
+node-api = { path = "../api" }
+node-primitives = { path = "../primitives" }
+node-runtime = { path = "../runtime" }
+substrate-client = { path = "../../core/client" }
+parity-codec = { path = "../../codec" }
+substrate-keyring = { path = "../../core/keyring" }
+substrate-extrinsic-pool = { path = "../../core/extrinsic-pool" }
+substrate-primitives = { path = "../../core/primitives" }
+sr-primitives = { path = "../../core/sr-primitives" }

substrate/node/transaction-pool/src/error.rs

@@ -0,0 +1,73 @@
+// 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/>.
+
+use extrinsic_pool;
+use node_api;
+use primitives::Hash;
+use runtime::{Address, UncheckedExtrinsic};
+
+error_chain! {
+	links {
+		Pool(extrinsic_pool::Error, extrinsic_pool::ErrorKind);
+		Api(node_api::Error, node_api::ErrorKind);
+	}
+	errors {
+		/// Unexpected extrinsic format submitted
+		InvalidExtrinsicFormat {
+			description("Invalid extrinsic format."),
+			display("Invalid extrinsic format."),
+		}
+		/// Attempted to queue an inherent transaction.
+		IsInherent(xt: UncheckedExtrinsic) {
+			description("Inherent transactions cannot be queued."),
+			display("Inherent transactions cannot be queued."),
+		}
+		/// Attempted to queue a transaction with bad signature.
+		BadSignature(e: &'static str) {
+			description("Transaction had bad signature."),
+			display("Transaction had bad signature: {}", e),
+		}
+		/// Attempted to queue a transaction that is already in the pool.
+		AlreadyImported(hash: Hash) {
+			description("Transaction is already in the pool."),
+			display("Transaction {:?} is already in the pool.", hash),
+		}
+		/// Import error.
+		Import(err: Box<::std::error::Error + Send>) {
+			description("Error importing transaction"),
+			display("Error importing transaction: {}", err.description()),
+		}
+		/// Runtime failure.
+		UnrecognisedAddress(who: Address) {
+			description("Unrecognised address in extrinsic"),
+			display("Unrecognised address in extrinsic: {}", who),
+		}
+		/// Extrinsic too large
+		TooLarge(got: usize, max: usize) {
+			description("Extrinsic too large"),
+			display("Extrinsic is too large ({} > {})", got, max),
+		}
+	}
+}
+
+impl extrinsic_pool::IntoPoolError for Error {
+	fn into_pool_error(self) -> ::std::result::Result<extrinsic_pool::Error, Self> {
+		match self {
+			Error(ErrorKind::Pool(e), c) => Ok(extrinsic_pool::Error(e, c)),
+			e => Err(e),
+		}
+	}
+}

substrate/node/transaction-pool/src/lib.rs

@@ -0,0 +1,236 @@
+// 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/>.
+
+extern crate substrate_client as client;
+extern crate parity_codec as codec;
+extern crate substrate_extrinsic_pool as extrinsic_pool;
+extern crate substrate_primitives;
+extern crate sr_primitives;
+extern crate node_runtime as runtime;
+extern crate node_primitives as primitives;
+extern crate node_api;
+extern crate parking_lot;
+
+#[cfg(test)]
+extern crate substrate_keyring;
+
+#[macro_use]
+extern crate error_chain;
+
+#[macro_use]
+extern crate log;
+
+mod error;
+
+use std::{
+	cmp::Ordering,
+	collections::HashMap,
+	sync::Arc,
+};
+
+use codec::{Decode, Encode};
+use extrinsic_pool::{Readiness, scoring::{Change, Choice}, VerifiedFor, ExtrinsicFor};
+use node_api::Api;
+use primitives::{AccountId, BlockId, Block, Hash, Index};
+use runtime::{Address, UncheckedExtrinsic, RawAddress};
+use sr_primitives::traits::{Bounded, Checkable, Hash as HashT, BlakeTwo256};
+
+pub use extrinsic_pool::{Options, Status, LightStatus, VerifiedTransaction as VerifiedTransactionOps};
+pub use error::{Error, ErrorKind, Result};
+
+/// Maximal size of a single encoded extrinsic.
+const MAX_TRANSACTION_SIZE: usize = 4 * 1024 * 1024;
+
+/// Type alias for convenience.
+pub type CheckedExtrinsic = <UncheckedExtrinsic as Checkable<fn(Address) -> std::result::Result<AccountId, &'static str>>>::Checked;
+
+/// Type alias for the transaction pool.
+pub type TransactionPool<A> = extrinsic_pool::Pool<ChainApi<A>>;
+
+/// A verified transaction which should be includable and non-inherent.
+#[derive(Clone, Debug)]
+pub struct VerifiedTransaction {
+	/// Transaction hash.
+	pub hash: Hash,
+	/// Transaction sender.
+	pub sender: AccountId,
+	/// Transaction index.
+	pub index: Index,
+	encoded_size: usize,
+}
+
+impl VerifiedTransaction {
+	/// Get the 256-bit hash of this transaction.
+	pub fn hash(&self) -> &Hash {
+		&self.hash
+	}
+
+	/// Get the account ID of the sender of this transaction.
+	pub fn index(&self) -> Index {
+		self.index
+	}
+
+	/// Get encoded size of the transaction.
+	pub fn encoded_size(&self) -> usize {
+		self.encoded_size
+	}
+}
+
+impl extrinsic_pool::VerifiedTransaction for VerifiedTransaction {
+	type Hash = Hash;
+	type Sender = AccountId;
+
+	fn hash(&self) -> &Self::Hash {
+		&self.hash
+	}
+
+	fn sender(&self) -> &Self::Sender {
+		&self.sender
+	}
+
+	fn mem_usage(&self) -> usize {
+		self.encoded_size // TODO
+	}
+}
+
+/// The transaction pool logic.
+pub struct ChainApi<A> {
+	api: Arc<A>,
+}
+
+impl<A> ChainApi<A> where
+	A: Api,
+{
+	/// Create a new instance.
+	pub fn new(api: Arc<A>) -> Self {
+		ChainApi {
+			api,
+		}
+	}
+}
+
+
+impl<A> extrinsic_pool::ChainApi for ChainApi<A> where
+	A: Api + Send + Sync,
+{
+	type Block = Block;
+	type Hash = Hash;
+	type Sender = AccountId;
+	type VEx = VerifiedTransaction;
+	type Ready = HashMap<AccountId, u64>;
+	type Error = Error;
+	type Score = u64;
+	type Event = ();
+
+	fn verify_transaction(&self, _at: &BlockId, xt: &ExtrinsicFor<Self>) -> Result<Self::VEx> {
+		let encoded = xt.encode();
+		let uxt = UncheckedExtrinsic::decode(&mut encoded.as_slice()).ok_or_else(|| ErrorKind::InvalidExtrinsicFormat)?;
+		if !uxt.is_signed() {
+			bail!(ErrorKind::IsInherent(uxt))
+		}
+
+		let (encoded_size, hash) = (encoded.len(), BlakeTwo256::hash(&encoded));
+		if encoded_size > MAX_TRANSACTION_SIZE {
+			bail!(ErrorKind::TooLarge(encoded_size, MAX_TRANSACTION_SIZE));
+		}
+
+		debug!(target: "transaction-pool", "Transaction submitted: {}", ::substrate_primitives::hexdisplay::HexDisplay::from(&encoded));
+		let checked = uxt.clone().check_with(|a| {
+			match a {
+				RawAddress::Id(id) => Ok(id),
+				RawAddress::Index(_) => Err("Index based addresses are not supported".into()),// TODO: Make index addressing optional in substrate
+			}
+		})?;
+		let sender = checked.signed.expect("Only signed extrinsics are allowed at this point");
+
+
+		if encoded_size < 1024 {
+			debug!(target: "transaction-pool", "Transaction verified: {} => {:?}", hash, uxt);
+		} else {
+			debug!(target: "transaction-pool", "Transaction verified: {} ({} bytes is too large to display)", hash, encoded_size);
+		}
+
+		Ok(VerifiedTransaction {
+			index: checked.index,
+			sender,
+			hash,
+			encoded_size,
+		})
+	}
+
+	fn ready(&self) -> Self::Ready {
+		HashMap::default()
+	}
+
+	fn is_ready(&self, at: &BlockId, known_nonces: &mut Self::Ready, xt: &VerifiedFor<Self>) -> Readiness {
+		let sender = xt.verified.sender().clone();
+		trace!(target: "transaction-pool", "Checking readiness of {} (from {})", xt.verified.hash, sender);
+
+		// TODO: find a way to handle index error properly -- will need changes to
+		// transaction-pool trait.
+		let api = &self.api;
+		let next_index = known_nonces.entry(sender)
+			.or_insert_with(|| api.index(at, sender).ok().unwrap_or_else(Bounded::max_value));
+
+		trace!(target: "transaction-pool", "Next index for sender is {}; xt index is {}", next_index, xt.verified.index);
+
+		let result = match xt.verified.index.cmp(&next_index) {
+			// TODO: this won't work perfectly since accounts can now be killed, returning the nonce
+			// to zero.
+			// We should detect if the index was reset and mark all transactions as `Stale` for cull to work correctly.
+			// Otherwise those transactions will keep occupying the queue.
+			// Perhaps we could mark as stale if `index - state_index` > X?
+			Ordering::Greater => Readiness::Future,
+			Ordering::Equal => Readiness::Ready,
+			// TODO [ToDr] Should mark transactions referencing too old blockhash as `Stale` as well.
+			Ordering::Less => Readiness::Stale,
+		};
+
+		// remember to increment `next_index`
+		*next_index = next_index.saturating_add(1);
+
+		result
+	}
+
+	fn compare(old: &VerifiedFor<Self>, other: &VerifiedFor<Self>) -> Ordering {
+		old.verified.index().cmp(&other.verified.index())
+	}
+
+	fn choose(old: &VerifiedFor<Self>, new: &VerifiedFor<Self>) -> Choice {
+		if old.verified.index() == new.verified.index() {
+			return Choice::ReplaceOld;
+		}
+		Choice::InsertNew
+	}
+
+	fn update_scores(
+		xts: &[extrinsic_pool::Transaction<VerifiedFor<Self>>],
+		scores: &mut [Self::Score],
+		_change: Change<()>
+	) {
+		for i in 0..xts.len() {
+			// all the same score since there are no fees.
+			// TODO: prioritize things like misbehavior or fishermen reports
+			scores[i] = 1;
+		}
+	}
+
+	fn should_replace(_old: &VerifiedFor<Self>, _new: &VerifiedFor<Self>) -> Choice {
+		// Don't allow new transactions if we are reaching the limit.
+		Choice::RejectNew
+	}
+}
+