Split polkadot-service (#310)

* Substrate service

* Splitting polkadot service

* Specialised components

* Specialised components

* Docs and style

* Docs and style

* Final touches

* Added db key assertion

polkadot/api/src/full.rs

@@ -16,7 +16,7 @@
 
 //! Strongly typed API for full Polkadot client.
 
-use client::backend::{Backend, LocalBackend};
+use client::backend::LocalBackend;
 use client::block_builder::BlockBuilder as ClientBlockBuilder;
 use client::{Client, LocalCallExecutor};
 use polkadot_executor::Executor as LocalDispatch;
@@ -57,9 +57,7 @@ macro_rules! with_runtime {
 	}}
 }
 
-impl<B: LocalBackend<Block>> BlockBuilder for ClientBlockBuilder<B, LocalCallExecutor<B, NativeExecutor<LocalDispatch>>, Block>
-	where ::client::error::Error: From<<<B as Backend<Block>>::State as state_machine::backend::Backend>::Error>
-{
+impl<B: LocalBackend<Block>> BlockBuilder for ClientBlockBuilder<B, LocalCallExecutor<B, NativeExecutor<LocalDispatch>>, Block> {
 	fn push_extrinsic(&mut self, extrinsic: UncheckedExtrinsic) -> Result<()> {
 		self.push(extrinsic).map_err(Into::into)
 	}
@@ -70,9 +68,7 @@ impl<B: LocalBackend<Block>> BlockBuilder for ClientBlockBuilder<B, LocalCallExe
 	}
 }
 
-impl<B: LocalBackend<Block>> PolkadotApi for Client<B, LocalCallExecutor<B, NativeExecutor<LocalDispatch>>, Block>
-	where ::client::error::Error: From<<<B as Backend<Block>>::State as state_machine::backend::Backend>::Error>
-{
+impl<B: LocalBackend<Block>> PolkadotApi for Client<B, LocalCallExecutor<B, NativeExecutor<LocalDispatch>>, Block> {
 	type BlockBuilder = ClientBlockBuilder<B, LocalCallExecutor<B, NativeExecutor<LocalDispatch>>, Block>;
 
 	fn session_keys(&self, at: &BlockId) -> Result<Vec<SessionKey>> {
@@ -160,7 +156,6 @@ impl<B: LocalBackend<Block>> PolkadotApi for Client<B, LocalCallExecutor<B, Nati
 }
 
 impl<B: LocalBackend<Block>> LocalPolkadotApi for Client<B, LocalCallExecutor<B, NativeExecutor<LocalDispatch>>, Block>
-	where ::client::error::Error: From<<<B as Backend<Block>>::State as state_machine::backend::Backend>::Error>
 {}
 
 #[cfg(test)]

polkadot/api/src/light.rs

@@ -20,7 +20,6 @@ use std::sync::Arc;
 use client::backend::{Backend, RemoteBackend};
 use client::{Client, CallExecutor};
 use codec::Slicable;
-use state_machine;
 use primitives::{AccountId, Block, BlockId, Hash, Index, SessionKey, Timestamp, UncheckedExtrinsic};
 use runtime::Address;
 use primitives::parachain::{CandidateReceipt, DutyRoster, Id as ParaId};
@@ -43,9 +42,7 @@ impl BlockBuilder for LightBlockBuilder {
 /// Remote polkadot API implementation.
 pub struct RemotePolkadotApiWrapper<B: Backend<Block>, E: CallExecutor<Block>>(pub Arc<Client<B, E, Block>>);
 
-impl<B: Backend<Block>, E: CallExecutor<Block>> PolkadotApi for RemotePolkadotApiWrapper<B, E>
-	where ::client::error::Error: From<<<B as Backend<Block>>::State as state_machine::backend::Backend>::Error>
-{
+impl<B: Backend<Block>, E: CallExecutor<Block>> PolkadotApi for RemotePolkadotApiWrapper<B, E> {
 	type BlockBuilder = LightBlockBuilder;
 
 	fn session_keys(&self, at: &BlockId) -> Result<Vec<SessionKey>> {
@@ -104,6 +101,4 @@ impl<B: Backend<Block>, E: CallExecutor<Block>> PolkadotApi for RemotePolkadotAp
 	}
 }
 
-impl<B: RemoteBackend<Block>, E: CallExecutor<Block>> RemotePolkadotApi for RemotePolkadotApiWrapper<B, E>
-	where ::client::error::Error: From<<<B as Backend<Block>>::State as state_machine::backend::Backend>::Error>
-{}
+impl<B: RemoteBackend<Block>, E: CallExecutor<Block>> RemotePolkadotApi for RemotePolkadotApiWrapper<B, E> {}

polkadot/cli/Cargo.toml

@@ -27,11 +27,13 @@ serde = "1.0"
 exit-future = "0.1"
 substrate-client = { path = "../../substrate/client" }
 substrate-codec = { path = "../../substrate/codec" }
+substrate-extrinsic-pool = { path = "../../substrate/extrinsic-pool" }
 substrate-network = { path = "../../substrate/network" }
 substrate-primitives = { path = "../../substrate/primitives" }
 substrate-rpc = { path = "../../substrate/rpc" }
 substrate-rpc-servers = { path = "../../substrate/rpc-servers" }
 substrate-runtime-primitives = { path = "../../substrate/runtime/primitives" }
+substrate-service = { path = "../../substrate/service" }
 substrate-state-machine = { path = "../../substrate/state-machine" }
 substrate-telemetry = { path = "../../substrate/telemetry" }
 polkadot-primitives = { path = "../primitives" }

polkadot/cli/src/chain_spec.rs

@@ -39,10 +39,10 @@ pub enum ChainSpec {
 impl ChainSpec {
 	pub(crate) fn load(self) -> Result<service::ChainSpec, String> {
 		Ok(match self {
-			ChainSpec::PoC1Testnet => service::ChainSpec::poc_1_testnet_config()?,
-			ChainSpec::Development => service::ChainSpec::development_config(),
-			ChainSpec::LocalTestnet => service::ChainSpec::local_testnet_config(),
-			ChainSpec::StagingTestnet => service::ChainSpec::staging_testnet_config(),
+			ChainSpec::PoC1Testnet => service::chain_spec::poc_1_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(),
 			ChainSpec::Custom(f) => service::ChainSpec::from_json_file(PathBuf::from(f))?,
 		})
 	}

polkadot/cli/src/informant.rs

@@ -22,9 +22,9 @@ use service::{Service, Components};
 use tokio::runtime::TaskExecutor;
 use tokio::timer::Interval;
 use network::{SyncState, SyncProvider};
-use polkadot_primitives::Block;
-use state_machine;
-use client::{self, BlockchainEvents};
+use client::BlockchainEvents;
+use runtime_primitives::traits::{Header, As};
+use substrate_extrinsic_pool::api::ExtrinsicPool;
 
 const TIMER_INTERVAL_MS: u64 = 5000;
 
@@ -32,13 +32,12 @@ const TIMER_INTERVAL_MS: u64 = 5000;
 pub fn start<C>(service: &Service<C>, exit: ::exit_future::Exit, handle: TaskExecutor)
 	where
 		C: Components,
-		client::error::Error: From<<<<C as Components>::Backend as client::backend::Backend<Block>>::State as state_machine::Backend>::Error>,
 {
 	let interval = Interval::new(Instant::now(), Duration::from_millis(TIMER_INTERVAL_MS));
 
 	let network = service.network();
 	let client = service.client();
-	let txpool = service.transaction_pool();
+	let txpool = service.extrinsic_pool();
 
 	let display_notifications = interval.map_err(|e| debug!("Timer error: {:?}", e)).for_each(move |_| {
 		let sync_status = network.status();
@@ -52,8 +51,9 @@ pub fn start<C>(service: &Service<C>, exit: ::exit_future::Exit, handle: TaskExe
 				(SyncState::Downloading, Some(n)) => format!("Syncing, target=#{}", n),
 			};
 			let txpool_status = txpool.light_status();
-			info!(target: "polkadot", "{} ({} peers), best: #{} ({})", status, sync_status.num_peers, best_block.number, hash);
-			telemetry!("system.interval"; "status" => status, "peers" => num_peers, "height" => best_block.number, "best" => ?hash, "txcount" => txpool_status.transaction_count);
+			let best_number: u64 = best_block.number().as_();
+			info!(target: "polkadot", "{} ({} peers), best: #{} ({})", status, sync_status.num_peers, best_number, hash);
+			telemetry!("system.interval"; "status" => status, "peers" => num_peers, "height" => best_number, "best" => ?hash, "txcount" => txpool_status.transaction_count);
 		} else {
 			warn!("Error getting best block information");
 		}
@@ -66,7 +66,7 @@ pub fn start<C>(service: &Service<C>, exit: ::exit_future::Exit, handle: TaskExe
 		Ok(())
 	});
 
-	let txpool = service.transaction_pool();
+	let txpool = service.extrinsic_pool();
 	let display_txpool_import = txpool.import_notification_stream().for_each(move |_| {
 		let status = txpool.light_status();
 		telemetry!("txpool.import"; "mem_usage" => status.mem_usage, "count" => status.transaction_count, "sender" => status.senders);

polkadot/cli/src/lib.rs

@@ -41,6 +41,8 @@ extern crate substrate_rpc;
 extern crate substrate_rpc_servers as rpc;
 extern crate substrate_runtime_primitives as runtime_primitives;
 extern crate substrate_state_machine as state_machine;
+extern crate substrate_extrinsic_pool;
+extern crate substrate_service;
 extern crate polkadot_primitives;
 extern crate polkadot_runtime;
 extern crate polkadot_service as service;
@@ -76,7 +78,7 @@ use std::fs::File;
 use std::net::SocketAddr;
 use std::path::{Path, PathBuf};
 use substrate_telemetry::{init_telemetry, TelemetryConfig};
-use polkadot_primitives::{Block, BlockId};
+use polkadot_primitives::BlockId;
 use codec::Slicable;
 use client::BlockOrigin;
 use runtime_primitives::generic::SignedBlock;
@@ -141,8 +143,7 @@ pub trait Worker {
 	fn exit_only(self) -> Self::Exit;
 
 	/// Do work and schedule exit.
-	fn work<C: ServiceComponents>(self, service: &Service<C>) -> Self::Work
-		where ClientError: From<<<<C as ServiceComponents>::Backend as ClientBackend<PolkadotBlock>>::State as StateMachineBackend>::Error>;
+	fn work<C: ServiceComponents>(self, service: &Service<C>) -> Self::Work;
 }
 
 /// Parse command line arguments and start the node.
@@ -441,7 +442,6 @@ fn run_until_exit<C, W>(
 	where
 		C: service::Components,
 		W: Worker,
-		client::error::Error: From<<<<C as service::Components>::Backend as client::backend::Backend<Block>>::State as state_machine::Backend>::Error>,
 {
 	let (exit_send, exit) = exit_future::signal();
 
@@ -453,10 +453,11 @@ fn run_until_exit<C, W>(
 		let ws_address = parse_address("127.0.0.1:9944", "ws-port", matches)?;
 
 		let handler = || {
-			let chain = rpc::apis::chain::Chain::new(service.client(), executor.clone());
-			let author = rpc::apis::author::Author::new(service.client(), service.transaction_pool());
-			rpc::rpc_handler::<Block, _, _, _, _>(
-				service.client(),
+			let client = (&service as &substrate_service::Service<C>).client();
+			let chain = rpc::apis::chain::Chain::new(client.clone(), executor.clone());
+			let author = rpc::apis::author::Author::new(client.clone(), service.extrinsic_pool());
+			rpc::rpc_handler::<service::ComponentBlock<C>, _, _, _, _>(
+				client,
 				chain,
 				author,
 				sys_conf.clone(),

polkadot/collator/src/lib.rs

@@ -66,7 +66,7 @@ use client::BlockchainEvents;
 use polkadot_api::PolkadotApi;
 use polkadot_primitives::BlockId;
 use polkadot_primitives::parachain::{self, BlockData, HeadData, ConsolidatedIngress, Collation, Message, Id as ParaId};
-use polkadot_cli::{ClientError, ServiceComponents, ClientBackend, PolkadotBlock, StateMachineBackend, Service};
+use polkadot_cli::{ServiceComponents, Service};
 use polkadot_cli::Worker;
 
 /// Parachain context needed for collation.
@@ -213,9 +213,7 @@ impl<P, E> Worker for CollationNode<P, E> where
 		self.exit
 	}
 
-	fn work<C: ServiceComponents>(self, service: &Service<C>) -> Self::Work
-		where ClientError: From<<<<C as ServiceComponents>::Backend as ClientBackend<PolkadotBlock>>::State as StateMachineBackend>::Error>,
-	{
+	fn work<C: ServiceComponents>(self, service: &Service<C>) -> Self::Work {
 		let CollationNode { parachain_context, exit, para_id, key } = self;
 		let client = service.client();
 		let api = service.api();

polkadot/network/src/lib.rs

@@ -221,6 +221,12 @@ pub struct PolkadotProtocol {
 	next_req_id: u64,
 }
 
+impl Default for PolkadotProtocol {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
 impl PolkadotProtocol {
 	/// Instantiate a polkadot protocol handler.
 	pub fn new() -> Self {

polkadot/service/Cargo.toml

@@ -4,18 +4,12 @@ version = "0.2.0"
 authors = ["Parity Technologies <admin@parity.io>"]
 
 [dependencies]
-futures = "0.1.17"
 parking_lot = "0.4"
 error-chain = "0.12"
 lazy_static = "1.0"
 log = "0.3"
 slog = "^2"
-clap = "2.27"
 tokio = "0.1.7"
-exit-future = "0.1"
-serde = "1.0"
-serde_json = "1.0"
-serde_derive = "1.0"
 hex-literal = "0.1"
 ed25519 = { path = "../../substrate/ed25519" }
 polkadot-primitives = { path = "../primitives" }
@@ -27,12 +21,9 @@ polkadot-transaction-pool = { path = "../transaction-pool" }
 polkadot-network = { path = "../network" }
 substrate-keystore = { path = "../../substrate/keystore" }
 substrate-runtime-io = { path = "../../substrate/runtime-io" }
-substrate-runtime-primitives = { path = "../../substrate/runtime/primitives" }
 substrate-primitives = { path = "../../substrate/primitives" }
 substrate-network = { path = "../../substrate/network" }
 substrate-client = { path = "../../substrate/client" }
-substrate-client-db = { path = "../../substrate/client/db" }
 substrate-codec = { path = "../../substrate/codec" }
-substrate-executor = { path = "../../substrate/executor" }
-substrate-state-machine = { path = "../../substrate/state-machine" }
+substrate-service = { path = "../../substrate/service" }
 substrate-telemetry = { path = "../../substrate/telemetry" }

polkadot/service/src/chain_spec.rs

@@ -17,133 +17,16 @@
 //! Polkadot chain configurations.
 
 use ed25519;
-use std::collections::HashMap;
-use std::fs::File;
-use std::path::PathBuf;
-use primitives::{AuthorityId, storage::{StorageKey, StorageData}};
-use runtime_primitives::{BuildStorage, StorageMap};
+use primitives::AuthorityId;
 use polkadot_runtime::{GenesisConfig, ConsensusConfig, CouncilConfig, DemocracyConfig,
 	SessionConfig, StakingConfig, TimestampConfig};
-use serde_json as json;
+use service::ChainSpec;
 
-enum GenesisSource {
-	File(PathBuf),
-	Embedded(&'static [u8]),
-	Factory(fn() -> Genesis),
+pub fn poc_1_testnet_config() -> Result<ChainSpec<GenesisConfig>, String> {
+	ChainSpec::from_embedded(include_bytes!("../res/poc-1.json"))
 }
 
-impl GenesisSource {
-	fn resolve(&self) -> Result<Genesis, String> {
-		#[derive(Serialize, Deserialize)]
-		struct GenesisContainer {
-			genesis: Genesis,
-		}
-
-		match *self {
-			GenesisSource::File(ref path) => {
-				let file = File::open(path).map_err(|e| format!("Error opening spec file: {}", e))?;
-				let genesis: GenesisContainer = json::from_reader(file).map_err(|e| format!("Error parsing spec file: {}", e))?;
-				Ok(genesis.genesis)
-			},
-			GenesisSource::Embedded(buf) => {
-				let genesis: GenesisContainer = json::from_reader(buf).map_err(|e| format!("Error parsing embedded file: {}", e))?;
-				Ok(genesis.genesis)
-			},
-			GenesisSource::Factory(f) => Ok(f()),
-		}
-	}
-}
-
-impl<'a> BuildStorage for &'a ChainSpec {
-	fn build_storage(self) -> Result<StorageMap, String> {
-		match self.genesis.resolve()? {
-			Genesis::Runtime(gc) => gc.build_storage(),
-			Genesis::Raw(map) => Ok(map.into_iter().map(|(k, v)| (k.0, v.0)).collect()),
-		}
-	}
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-#[serde(deny_unknown_fields)]
-enum Genesis {
-	Runtime(GenesisConfig),
-	Raw(HashMap<StorageKey, StorageData>),
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct ChainSpecFile {
-	pub name: String,
-	pub boot_nodes: Vec<String>,
-}
-
-/// A configuration of a chain. Can be used to build a genesis block.
-pub struct ChainSpec {
-	spec: ChainSpecFile,
-	genesis: GenesisSource,
-}
-
-impl ChainSpec {
-	pub fn boot_nodes(&self) -> &[String] {
-		&self.spec.boot_nodes
-	}
-
-	pub fn name(&self) -> &str {
-		&self.spec.name
-	}
-
-	/// Parse json content into a `ChainSpec`
-	pub fn from_embedded(json: &'static [u8]) -> Result<Self, String> {
-		let spec = json::from_slice(json).map_err(|e| format!("Error parsing spec file: {}", e))?;
-		Ok(ChainSpec {
-			spec,
-			genesis: GenesisSource::Embedded(json),
-		})
-	}
-
-	/// Parse json file into a `ChainSpec`
-	pub fn from_json_file(path: PathBuf) -> Result<Self, String> {
-		let file = File::open(&path).map_err(|e| format!("Error opening spec file: {}", e))?;
-		let spec = json::from_reader(file).map_err(|e| format!("Error parsing spec file: {}", e))?;
-		Ok(ChainSpec {
-			spec,
-			genesis: GenesisSource::File(path),
-		})
-	}
-
-	/// Dump to json string.
-	pub fn to_json(self, raw: bool) -> Result<String, String> {
-		#[derive(Serialize, Deserialize)]
-		struct Container {
-			#[serde(flatten)]
-			spec: ChainSpecFile,
-			#[serde(flatten)]
-			genesis: Genesis,
-
-		};
-		let genesis = match (raw, self.genesis.resolve()?) {
-			(true, Genesis::Runtime(g)) => {
-				let storage = g.build_storage()?.into_iter()
-					.map(|(k, v)| (StorageKey(k), StorageData(v)))
-					.collect();
-
-				Genesis::Raw(storage)
-			},
-			(_, genesis) => genesis,
-		};
-		let spec = Container {
-			spec: self.spec,
-			genesis,
-		};
-		json::to_string_pretty(&spec).map_err(|e| format!("Error generating spec json: {}", e))
-	}
-
-	pub fn poc_1_testnet_config() -> Result<Self, String> {
-		Self::from_embedded(include_bytes!("../res/poc-1.json"))
-	}
-
-	fn staging_testnet_config_genesis() -> Genesis {
+fn staging_testnet_config_genesis() -> GenesisConfig {
 	let initial_authorities = vec![
 		hex!["82c39b31a2b79a90f8e66e7a77fdb85a4ed5517f2ae39f6a80565e8ecae85cf5"].into(),
 		hex!["4de37a07567ebcbf8c64568428a835269a566723687058e017b6d69db00a77e7"].into(),
@@ -153,7 +36,7 @@ impl ChainSpec {
 	let endowed_accounts = vec![
 		hex!["f295940fa750df68a686fcf4abd4111c8a9c5a5a5a83c4c8639c451a94a7adfd"].into(),
 	];
-		Genesis::Runtime(GenesisConfig {
+	GenesisConfig {
 		consensus: Some(ConsensusConfig {
 			code: include_bytes!("../../runtime/wasm/genesis.wasm").to_vec(),	// TODO change
 			authorities: initial_authorities.clone(),
@@ -205,22 +88,20 @@ impl ChainSpec {
 		timestamp: Some(TimestampConfig {
 			period: 5,					// 5 second block time.
 		}),
-		})
 	}
-	/// Staging testnet config.
-	pub fn staging_testnet_config() -> Self {
+}
+
+/// Staging testnet config.
+pub fn staging_testnet_config() -> ChainSpec<GenesisConfig> {
 	let boot_nodes = vec![
 		"enode://a93a29fa68d965452bf0ff8c1910f5992fe2273a72a1ee8d3a3482f68512a61974211ba32bb33f051ceb1530b8ba3527fc36224ba6b9910329025e6d9153cf50@104.211.54.233:30333".into(),
 		"enode://051b18f63a316c4c5fef4631f8c550ae0adba179153588406fac3e5bbbbf534ebeda1bf475dceda27a531f6cdef3846ab6a010a269aa643a1fec7bff51af66bd@104.211.48.51:30333".into(),
 		"enode://c831ec9011d2c02d2c4620fc88db6d897a40d2f88fd75f47b9e4cf3b243999acb6f01b7b7343474650b34eeb1363041a422a91f1fc3850e43482983ee15aa582@104.211.48.247:30333".into(),
 	];
-		ChainSpec {
-			spec: ChainSpecFile { name: "Staging Testnet".to_owned(), boot_nodes },
-			genesis: GenesisSource::Factory(Self::staging_testnet_config_genesis),
-		}
-	}
+	ChainSpec::from_genesis("Staging Testnet", staging_testnet_config_genesis, boot_nodes)
+}
 
-	fn testnet_genesis(initial_authorities: Vec<AuthorityId>) -> Genesis {
+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(),
@@ -229,7 +110,7 @@ impl ChainSpec {
 		ed25519::Pair::from_seed(b"Eve                             ").public().0.into(),
 		ed25519::Pair::from_seed(b"Ferdie                          ").public().0.into(),
 	];
-		Genesis::Runtime(GenesisConfig {
+	GenesisConfig {
 		consensus: Some(ConsensusConfig {
 			code: include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.compact.wasm").to_vec(),
 			authorities: initial_authorities.clone(),
@@ -281,35 +162,28 @@ impl ChainSpec {
 		timestamp: Some(TimestampConfig {
 			period: 5,					// 5 second block time.
 		}),
-		})
 	}
+}
 
-	fn development_config_genesis() -> Genesis {
-		Self::testnet_genesis(vec![
+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() -> Self {
-		ChainSpec {
-			spec: ChainSpecFile { name: "Development".to_owned(), boot_nodes: vec![] },
-			genesis: GenesisSource::Factory(Self::development_config_genesis),
-		}
-	}
+/// Development config (single validator Alice)
+pub fn development_config() -> ChainSpec<GenesisConfig> {
+	ChainSpec::from_genesis("Development", development_config_genesis, vec![])
+}
 
-	fn local_testnet_genesis() -> Genesis {
-		Self::testnet_genesis(vec![
+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() -> Self {
-		ChainSpec {
-			spec: ChainSpecFile { name: "Local Testnet".to_owned(), boot_nodes: vec![] },
-			genesis: GenesisSource::Factory(Self::local_testnet_genesis),
-		}
-	}
+}
+
+/// Local testnet config (multivalidator Alice + Bob)
+pub fn local_testnet_config() -> ChainSpec<GenesisConfig> {
+	ChainSpec::from_genesis("Local Testnet", local_testnet_genesis, vec![])
 }

polkadot/service/src/components.rs

@@ -1,258 +0,0 @@
-// Copyright 2017 Parity Technologies (UK) Ltd.
-// This file is part of Polkadot.
-
-// Polkadot 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.
-
-// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.?
-
-//! Polkadot service components.
-
-use std::collections::HashMap;
-use std::sync::Arc;
-use chain_spec::ChainSpec;
-use client_db;
-use client::{self, Client};
-use codec::{self, Slicable};
-use consensus;
-use error;
-use keystore::Store as Keystore;
-use network::{self, OnDemand};
-use polkadot_api;
-use polkadot_executor::Executor as LocalDispatch;
-use polkadot_network::NetworkService;
-use polkadot_primitives::{Block, BlockId, Hash};
-use state_machine::{self, ExecutionStrategy};
-use substrate_executor::NativeExecutor;
-use transaction_pool::{self, TransactionPool};
-use tokio::runtime::TaskExecutor;
-
-/// Code executor.
-pub type CodeExecutor = NativeExecutor<LocalDispatch>;
-
-/// Polkadot service components.
-pub trait Components {
-	/// Client backend type.
-	type Backend: 'static + client::backend::Backend<Block>;
-
-	/// Polkadot API type.
-	type Api: 'static + polkadot_api::PolkadotApi + Send + Sync;
-
-	/// Code executor type.
-	type Executor: 'static + client::CallExecutor<Block> + Send + Sync;
-
-	/// Create client.
-	fn build_client(&self, settings: client_db::DatabaseSettings, executor: CodeExecutor, chain_spec: &ChainSpec, execution_strategy: ExecutionStrategy)
-		-> Result<(Arc<Client<Self::Backend, Self::Executor, Block>>, Option<Arc<OnDemand<Block, NetworkService>>>), error::Error>;
-
-	/// Create api.
-	fn build_api(&self, client: Arc<Client<Self::Backend, Self::Executor, Block>>) -> Arc<Self::Api>;
-
-	/// Create network transaction pool adapter.
-	fn build_network_tx_pool(&self, client: Arc<client::Client<Self::Backend, Self::Executor, Block>>, tx_pool: Arc<TransactionPool<Self::Api>>)
-		-> Arc<network::TransactionPool<Block>>;
-
-	/// Create consensus service.
-	fn build_consensus(
-		&self,
-		client: Arc<Client<Self::Backend, Self::Executor, Block>>,
-		network: Arc<NetworkService>,
-		tx_pool: Arc<TransactionPool<Self::Api>>,
-		keystore: &Keystore,
-		task_executor: TaskExecutor,
-	)
-		-> Result<Option<consensus::Service>, error::Error>;
-}
-
-/// Components for full Polkadot service.
-pub struct FullComponents {
-	/// Is this a validator node?
-	pub is_validator: bool,
-}
-
-impl Components for FullComponents {
-	type Backend = client_db::Backend<Block>;
-	type Api = Client<Self::Backend, Self::Executor, Block>;
-	type Executor = client::LocalCallExecutor<client_db::Backend<Block>, NativeExecutor<LocalDispatch>>;
-
-	fn build_client(&self, db_settings: client_db::DatabaseSettings, executor: CodeExecutor, chain_spec: &ChainSpec, execution_strategy: ExecutionStrategy)
-		-> Result<(Arc<client::Client<Self::Backend, Self::Executor, Block>>, Option<Arc<OnDemand<Block, NetworkService>>>), error::Error> {
-		Ok((Arc::new(client_db::new_client(db_settings, executor, chain_spec, execution_strategy)?), None))
-	}
-
-	fn build_api(&self, client: Arc<client::Client<Self::Backend, Self::Executor, Block>>) -> Arc<Self::Api> {
-		client
-	}
-
-	fn build_network_tx_pool(&self, client: Arc<client::Client<Self::Backend, Self::Executor, Block>>, pool: Arc<TransactionPool<Self::Api>>)
-		-> Arc<network::TransactionPool<Block>> {
-		Arc::new(TransactionPoolAdapter {
-			imports_external_transactions: true,
-			pool,
-			client,
-		})
-	}
-
-	fn build_consensus(
-		&self,
-		client: Arc<client::Client<Self::Backend, Self::Executor, Block>>,
-		network: Arc<NetworkService>,
-		tx_pool: Arc<TransactionPool<Self::Api>>,
-		keystore: &Keystore,
-		task_executor: TaskExecutor,
-	)
-		-> Result<Option<consensus::Service>, error::Error>
-	{
-		if !self.is_validator {
-			return Ok(None);
-		}
-
-		// Load the first available key
-		let key = keystore.load(&keystore.contents()?[0], "")?;
-		info!("Using authority key {}", key.public());
-
-		let consensus_net = ::polkadot_network::consensus::ConsensusNetwork::new(network, client.clone());
-		Ok(Some(consensus::Service::new(
-			client.clone(),
-			client.clone(),
-			consensus_net,
-			tx_pool.clone(),
-			task_executor,
-			::std::time::Duration::from_millis(4000), // TODO: dynamic
-			key,
-		)))
-	}
-}
-
-/// Components for light Polkadot service.
-pub struct LightComponents;
-
-impl Components for LightComponents {
-	type Backend = client::light::backend::Backend<client_db::light::LightStorage<Block>, network::OnDemand<Block, NetworkService>>;
-	type Api = polkadot_api::light::RemotePolkadotApiWrapper<Self::Backend, Self::Executor>;
-	type Executor = client::light::call_executor::RemoteCallExecutor<
-		client::light::blockchain::Blockchain<client_db::light::LightStorage<Block>, network::OnDemand<Block, NetworkService>>,
-		network::OnDemand<Block, NetworkService>>;
-
-	fn build_client(&self, db_settings: client_db::DatabaseSettings, executor: CodeExecutor, spec: &ChainSpec, _execution_strategy: ExecutionStrategy)
-		-> Result<(Arc<client::Client<Self::Backend, Self::Executor, Block>>, Option<Arc<OnDemand<Block, NetworkService>>>), error::Error> {
-		let db_storage = client_db::light::LightStorage::new(db_settings)?;
-		let light_blockchain = client::light::new_light_blockchain(db_storage);
-		let fetch_checker = Arc::new(client::light::new_fetch_checker(light_blockchain.clone(), executor));
-		let fetcher = Arc::new(network::OnDemand::new(fetch_checker));
-		let client_backend = client::light::new_light_backend(light_blockchain, fetcher.clone());
-		let client = client::light::new_light(client_backend, fetcher.clone(), spec)?;
-		Ok((Arc::new(client), Some(fetcher)))
-	}
-
-	fn build_api(&self, client: Arc<client::Client<Self::Backend, Self::Executor, Block>>) -> Arc<Self::Api> {
-		Arc::new(polkadot_api::light::RemotePolkadotApiWrapper(client.clone()))
-	}
-
-	fn build_network_tx_pool(&self, client: Arc<client::Client<Self::Backend, Self::Executor, Block>>, pool: Arc<TransactionPool<Self::Api>>)
-		-> Arc<network::TransactionPool<Block>> {
-		Arc::new(TransactionPoolAdapter {
-			imports_external_transactions: false,
-			pool,
-			client,
-		})
-	}
-
-	fn build_consensus(
-		&self,
-		_client: Arc<client::Client<Self::Backend, Self::Executor, Block>>,
-		_network: Arc<NetworkService>,
-		_tx_pool: Arc<TransactionPool<Self::Api>>,
-		_keystore: &Keystore,
-		_task_executor: TaskExecutor,
-	)
-		-> Result<Option<consensus::Service>, error::Error>
-	{
-		Ok(None)
-	}
-}
-
-/// Transaction pool adapter.
-pub struct TransactionPoolAdapter<B, E, A> where A: Send + Sync, E: Send + Sync {
-	imports_external_transactions: bool,
-	pool: Arc<TransactionPool<A>>,
-	client: Arc<Client<B, E, Block>>,
-}
-
-impl<B, E, A> TransactionPoolAdapter<B, E, A>
-	where
-		A: Send + Sync,
-		B: client::backend::Backend<Block> + Send + Sync,
-		E: client::CallExecutor<Block> + Send + Sync,
-		client::error::Error: From<<<B as client::backend::Backend<Block>>::State as state_machine::backend::Backend>::Error>,
-{
-	fn best_block_id(&self) -> Option<BlockId> {
-		self.client.info()
-			.map(|info| BlockId::hash(info.chain.best_hash))
-			.map_err(|e| {
-				debug!("Error getting best block: {:?}", e);
-			})
-			.ok()
-	}
-}
-
-impl<B, E, A> network::TransactionPool<Block> for TransactionPoolAdapter<B, E, A>
-	where
-		B: client::backend::Backend<Block> + Send + Sync,
-		E: client::CallExecutor<Block> + Send + Sync,
-		client::error::Error: From<<<B as client::backend::Backend<Block>>::State as state_machine::backend::Backend>::Error>,
-		A: polkadot_api::PolkadotApi + Send + Sync,
-{
-	fn transactions(&self) -> Vec<(Hash, Vec<u8>)> {
-		let best_block_id = match self.best_block_id() {
-			Some(id) => id,
-			None => return vec![],
-		};
-		self.pool.cull_and_get_pending(best_block_id, |pending| pending
-			.map(|t| {
-				let hash = t.hash().clone();
-				(hash, t.primitive_extrinsic())
-			})
-			.collect()
-		).unwrap_or_else(|e| {
-			warn!("Error retrieving pending set: {}", e);
-			vec![]
-		})
-	}
-
-	fn import(&self, transaction: &Vec<u8>) -> Option<Hash> {
-		if !self.imports_external_transactions {
-			return None;
-		}
-
-		let encoded = transaction.encode();
-		if let Some(uxt) = codec::Slicable::decode(&mut &encoded[..]) {
-			let best_block_id = self.best_block_id()?;
-			match self.pool.import_unchecked_extrinsic(best_block_id, uxt) {
-				Ok(xt) => Some(*xt.hash()),
-				Err(e) => match *e.kind() {
-					transaction_pool::ErrorKind::AlreadyImported(hash) => Some(hash[..].into()),
-					_ => {
-						debug!("Error adding transaction to the pool: {:?}", e);
-						None
-					},
-				}
-			}
-		} else {
-			debug!("Error decoding transaction");
-			None
-		}
-	}
-
-	fn on_broadcasted(&self, propagations: HashMap<Hash, Vec<String>>) {
-		self.pool.on_broadcasted(propagations)
-	}
-}

polkadot/service/src/config.rs

@@ -1,71 +0,0 @@
-// Copyright 2017 Parity Technologies (UK) Ltd.
-// This file is part of Polkadot.
-
-// Polkadot 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.
-
-// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.?
-
-//! Service configuration.
-
-use transaction_pool;
-use chain_spec::ChainSpec;
-pub use state_machine::ExecutionStrategy;
-pub use network::Role;
-pub use network::NetworkConfiguration;
-pub use client_db::PruningMode;
-
-/// Service configuration.
-pub struct Configuration {
-	/// Node roles.
-	pub roles: Role,
-	/// Transaction pool configuration.
-	pub transaction_pool: transaction_pool::Options,
-	/// Network configuration.
-	pub network: NetworkConfiguration,
-	/// Path to key files.
-	pub keystore_path: String,
-	/// Path to the database.
-	pub database_path: String,
-	/// Pruning settings.
-	pub pruning: PruningMode,
-	/// Additional key seeds.
-	pub keys: Vec<String>,
-	/// Chain configuration.
-	pub chain_spec: ChainSpec,
-	/// Telemetry server URL, optional - only `Some` if telemetry reporting is enabled
-	pub telemetry: Option<String>,
-	/// Node name.
-	pub name: String,
-	/// Execution strategy.
-	pub execution_strategy: ExecutionStrategy,
-}
-
-impl Configuration {
-	/// Create default config for given chain spec.
-	pub fn default_with_spec(chain_spec: ChainSpec) -> Configuration {
-		let mut configuration = Configuration {
-			chain_spec,
-			name: Default::default(),
-			roles: Role::FULL,
-			transaction_pool: Default::default(),
-			network: Default::default(),
-			keystore_path: Default::default(),
-			database_path: Default::default(),
-			keys: Default::default(),
-			telemetry: Default::default(),
-			pruning: PruningMode::ArchiveAll,
-			execution_strategy: ExecutionStrategy::Both,
-		};
-		configuration.network.boot_nodes = configuration.chain_spec.boot_nodes().to_vec();
-		configuration
-	}
-}

polkadot/service/src/error.rs

@@ -1,32 +0,0 @@
-// Copyright 2017 Parity Technologies (UK) Ltd.
-// This file is part of Polkadot.
-
-// Polkadot 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.
-
-// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
-
-//! Errors that can occur during the service operation.
-
-use client;
-use network;
-use keystore;
-
-error_chain! {
-	links {
-		Client(client::error::Error, client::error::ErrorKind) #[doc="Client error"];
-		Network(network::error::Error, network::error::ErrorKind) #[doc="Network error"];
-		Keystore(keystore::Error, keystore::ErrorKind) #[doc="Keystore error"];
-	}
-
-	errors {
-	}
-}

polkadot/service/src/lib.rs

@@ -14,15 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-//! Polkadot service. Starts a thread that spins the network, the client and the transaction pool.
-//! Manages communication between them.
+#![warn(unused_extern_crates)]
+
+//! Polkadot service. Specialized wrapper over substrate service.
 
-extern crate futures;
 extern crate ed25519;
-extern crate clap;
-extern crate exit_future;
-extern crate serde;
-extern crate serde_json;
 extern crate polkadot_primitives;
 extern crate polkadot_runtime;
 extern crate polkadot_executor;
@@ -32,236 +28,291 @@ extern crate polkadot_transaction_pool as transaction_pool;
 extern crate polkadot_network;
 extern crate substrate_keystore as keystore;
 extern crate substrate_primitives as primitives;
-extern crate substrate_runtime_primitives as runtime_primitives;
 extern crate substrate_network as network;
 extern crate substrate_codec as codec;
-extern crate substrate_executor;
-extern crate substrate_state_machine as state_machine;
 extern crate substrate_client as client;
-extern crate substrate_client_db as client_db;
+extern crate substrate_service as service;
 extern crate tokio;
 
-#[macro_use]
-extern crate substrate_telemetry;
-#[macro_use]
-extern crate error_chain;
-#[macro_use]
-extern crate slog;	// needed until we can reexport `slog_info` from `substrate_telemetry`
 #[macro_use]
 extern crate log;
 #[macro_use]
-extern crate serde_derive;
-#[macro_use]
 extern crate hex_literal;
 
-mod components;
-mod error;
-mod config;
-mod chain_spec;
+pub mod chain_spec;
 
 use std::sync::Arc;
-use futures::prelude::*;
+use std::collections::HashMap;
+
+use codec::Slicable;
 use transaction_pool::TransactionPool;
 use keystore::Store as Keystore;
-use polkadot_api::PolkadotApi;
+use polkadot_api::{PolkadotApi, light::RemotePolkadotApiWrapper};
 use polkadot_primitives::{Block, BlockId, Hash};
-use client::{Client, BlockchainEvents};
-use network::ManageNetwork;
-use exit_future::Signal;
-use polkadot_network::{NetworkService, PolkadotProtocol};
+use polkadot_runtime::GenesisConfig;
+use client::Client;
+use polkadot_network::{PolkadotProtocol, consensus::ConsensusNetwork};
 use tokio::runtime::TaskExecutor;
 
-pub use self::error::{ErrorKind, Error};
-pub use self::components::{Components, FullComponents, LightComponents};
-pub use config::{Configuration, Role, PruningMode, ExecutionStrategy};
-pub use chain_spec::ChainSpec;
+pub use service::{Configuration, Role, PruningMode, ExtrinsicPoolOptions,
+	ErrorKind, Error, ComponentBlock, LightComponents, FullComponents};
+pub use client::ExecutionStrategy;
+
+/// Specialised polkadot `ChainSpec`.
+pub type ChainSpec = service::ChainSpec<GenesisConfig>;
+/// Polkadot client type for specialised `Components`.
+pub type ComponentClient<C> = Client<<C as Components>::Backend, <C as Components>::Executor, Block>;
+
+/// A collection of type to generalise Polkadot specific components over full / light client.
+pub trait Components: service::Components {
+	/// Polkadot API.
+	type Api: 'static + PolkadotApi + Send + Sync;
+	/// Client backend.
+	type Backend: 'static + client::backend::Backend<Block>;
+	/// Client executor.
+	type Executor: 'static + client::CallExecutor<Block> + Send + Sync;
+}
+
+impl Components for service::LightComponents<Factory> {
+	type Api = RemotePolkadotApiWrapper<
+		<service::LightComponents<Factory> as service::Components>::Backend,
+		<service::LightComponents<Factory> as service::Components>::Executor,
+	>;
+	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>;
+}
+
+/// Polkadot config for the substrate service.
+pub struct Factory;
+
+impl service::ServiceFactory for Factory {
+	type Block = Block;
+	type NetworkProtocol = PolkadotProtocol;
+	type RuntimeDispatch = polkadot_executor::Executor;
+	type FullExtrinsicPool = TransactionPoolAdapter<
+		service::FullBackend<Self>,
+		service::FullExecutor<Self>,
+		service::FullClient<Self>
+	>;
+	type LightExtrinsicPool = TransactionPoolAdapter<
+		service::LightBackend<Self>,
+		service::LightExecutor<Self>,
+		RemotePolkadotApiWrapper<service::LightBackend<Self>, service::LightExecutor<Self>>
+	>;
+	type Genesis = GenesisConfig;
+
+	const NETWORK_PROTOCOL_ID: network::ProtocolId = ::polkadot_network::DOT_PROTOCOL_ID;
+
+	fn build_full_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<service::FullClient<Self>>)
+		-> Result<Self::FullExtrinsicPool, Error>
+	{
+		let api = client.clone();
+		Ok(TransactionPoolAdapter {
+			pool: Arc::new(TransactionPool::new(config, api)),
+			client: client,
+			imports_external_transactions: true,
+		})
+	}
+
+	fn build_light_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<service::LightClient<Self>>)
+		-> Result<Self::LightExtrinsicPool, Error>
+	{
+		let api = Arc::new(RemotePolkadotApiWrapper(client.clone()));
+		Ok(TransactionPoolAdapter {
+			pool: Arc::new(TransactionPool::new(config, api)),
+			client: client,
+			imports_external_transactions: false,
+		})
+	}
+}
 
 /// Polkadot service.
-pub struct Service<Components: components::Components> {
-	client: Arc<Client<Components::Backend, Components::Executor, Block>>,
-	api: Arc<Components::Api>,
-	network: Arc<NetworkService>,
-	transaction_pool: Arc<TransactionPool<Components::Api>>,
-	signal: Option<Signal>,
+pub struct Service<C: Components> {
+	inner: service::Service<C>,
+	client: Arc<ComponentClient<C>>,
+	api: Arc<<C as Components>::Api>,
 	_consensus: Option<consensus::Service>,
 }
 
-/// Creates light client and register protocol with the network service
-pub fn new_light(config: Configuration, executor: TaskExecutor) -> Result<Service<components::LightComponents>, error::Error> {
-	Service::new(components::LightComponents, config, executor)
-}
-
-/// Creates full client and register protocol with the network service
-pub fn new_full(config: Configuration, executor: TaskExecutor) -> Result<Service<components::FullComponents>, error::Error> {
-	let is_validator = (config.roles & Role::AUTHORITY) == Role::AUTHORITY;
-	Service::new(components::FullComponents { is_validator }, config, executor)
-}
-
-/// Creates bare client without any networking.
-pub fn new_client(config: Configuration) -> Result<Arc<Client<
-		<components::FullComponents as Components>::Backend,
-		<components::FullComponents as Components>::Executor,
-		Block>>,
-	error::Error>
-{
-	let db_settings = client_db::DatabaseSettings {
-		cache_size: None,
-		path: config.database_path.into(),
-		pruning: config.pruning,
-	};
-	let executor = polkadot_executor::Executor::new();
-	let is_validator = (config.roles & Role::AUTHORITY) == Role::AUTHORITY;
-	let components = components::FullComponents { is_validator };
-	let (client, _) = components.build_client(db_settings, executor, &config.chain_spec, config.execution_strategy)?;
-	Ok(client)
-}
-
-impl<Components> Service<Components>
-	where
-		Components: components::Components,
-		client::error::Error: From<<<<Components as components::Components>::Backend as client::backend::Backend<Block>>::State as state_machine::Backend>::Error>,
-{
-	/// Creates and register protocol with the network service
-	fn new(components: Components, config: Configuration, task_executor: TaskExecutor) -> Result<Self, error::Error> {
-		let (signal, exit) = ::exit_future::signal();
-
-		// Create client
-		let executor = polkadot_executor::Executor::with_heap_pages(128);
-
-		let mut keystore = Keystore::open(config.keystore_path.into())?;
-		for seed in &config.keys {
-			keystore.generate_from_seed(seed)?;
-		}
-
-		if keystore.contents()?.is_empty() {
-			let key = keystore.generate("")?;
-			info!("Generated a new keypair: {:?}", key.public());
-		}
-
-		let db_settings = client_db::DatabaseSettings {
-			cache_size: None,
-			path: config.database_path.into(),
-			pruning: config.pruning,
-		};
-
-		let (client, on_demand) = components.build_client(db_settings, executor, &config.chain_spec, config.execution_strategy)?;
-		let api = components.build_api(client.clone());
-		let best_header = client.best_block_header()?;
-
-		info!("Best block: #{}", best_header.number);
-		telemetry!("node.start"; "height" => best_header.number, "best" => ?best_header.hash());
-
-		let transaction_pool = Arc::new(TransactionPool::new(config.transaction_pool, api.clone()));
-		let transaction_pool_adapter = components.build_network_tx_pool(client.clone(), transaction_pool.clone());
-		let network_params = network::Params {
-			config: network::ProtocolConfig {
-				roles: config.roles,
-			},
-			network_config: config.network,
-			chain: client.clone(),
-			on_demand: on_demand.clone().map(|d| d as Arc<network::OnDemandService<Block>>),
-			transaction_pool: transaction_pool_adapter,
-			specialization: PolkadotProtocol::new(),
-		};
-
-		let network = network::Service::new(network_params, ::polkadot_network::DOT_PROTOCOL_ID)?;
-		on_demand.map(|on_demand| on_demand.set_service_link(Arc::downgrade(&network)));
-
-		network.start_network();
-
-		{
-			// block notifications
-			let network = network.clone();
-			let txpool = transaction_pool.clone();
-
-			let events = client.import_notification_stream()
-				.for_each(move |notification| {
-					network.on_block_imported(notification.hash, &notification.header);
-					prune_imported(&*txpool, notification.hash);
-					Ok(())
-				})
-				.select(exit.clone())
-				.then(|_| Ok(()));
-			task_executor.spawn(events);
-		}
-
-		{
-			// transaction notifications
-			let network = network.clone();
-			let events = transaction_pool.import_notification_stream()
-				// TODO [ToDr] Consider throttling?
-				.for_each(move |_| {
-					network.trigger_repropagate();
-					Ok(())
-				})
-				.select(exit.clone())
-				.then(|_| Ok(()));
-
-			task_executor.spawn(events);
-		}
-
-		// Spin consensus service if configured
-		let consensus_service = components.build_consensus(
-			client.clone(),
-			network.clone(),
-			transaction_pool.clone(),
-			&keystore,
-			task_executor,
-		)?;
-
-		Ok(Service {
-			client: client,
-			network: network,
-			transaction_pool: transaction_pool,
-			signal: Some(signal),
-			api: api,
-			_consensus: consensus_service,
-		})
-	}
-
-	/// Get shared client instance.
-	pub fn client(&self) -> Arc<Client<Components::Backend, Components::Executor, Block>> {
+impl <C: Components> Service<C> {
+	pub fn client(&self) -> Arc<ComponentClient<C>> {
 		self.client.clone()
 	}
 
-	/// Get shared polkadot-api instance. usually the same as the client.
-	pub fn api(&self) -> Arc<Components::Api> {
+	pub fn api(&self) -> Arc<<C as Components>::Api> {
 		self.api.clone()
 	}
-
-	/// Get shared network instance.
-	pub fn network(&self) -> Arc<NetworkService> {
-		self.network.clone()
-	}
-
-	/// Get shared transaction pool instance.
-	pub fn transaction_pool(&self) -> Arc<TransactionPool<Components::Api>> {
-		self.transaction_pool.clone()
-	}
 }
 
-/// Produce a task which prunes any finalized transactions from the pool.
-pub fn prune_imported<A>(pool: &TransactionPool<A>, hash: Hash)
-	where A: PolkadotApi,
+/// Creates light client and register protocol with the network service
+pub fn new_light(config: Configuration<GenesisConfig>, executor: TaskExecutor)
+	-> Result<Service<LightComponents<Factory>>, Error>
 {
-	let block = BlockId::hash(hash);
-	if let Err(e) = pool.cull(block) {
+	let service = service::Service::<LightComponents<Factory>>::new(config, executor)?;
+	let api = Arc::new(RemotePolkadotApiWrapper(service.client()));
+	Ok(Service {
+		client: service.client(),
+		api: api,
+		inner: service,
+		_consensus: None,
+	})
+}
+
+/// Creates full client and register protocol with the network service
+pub fn new_full(config: Configuration<GenesisConfig>, executor: TaskExecutor)
+	-> Result<Service<FullComponents<Factory>>, Error>
+{
+	let keystore_path = config.keystore_path.clone();
+	let is_validator = (config.roles & Role::AUTHORITY) == Role::AUTHORITY;
+	let service = service::Service::<FullComponents<Factory>>::new(config, executor.clone())?;
+	let consensus = if is_validator {
+		// Spin consensus service if configured
+		let keystore = Keystore::open(keystore_path.into())?;
+		// Load the first available key
+		let key = keystore.load(&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,
+			::std::time::Duration::from_millis(4000), // TODO: dynamic
+			key,
+		))
+	} else {
+		None
+	};
+
+	Ok(Service {
+		client: service.client(),
+		api: service.client(),
+		inner: service,
+		_consensus: consensus,
+	})
+}
+
+/// Creates bare client without any networking.
+pub fn new_client(config: Configuration<GenesisConfig>)
+-> 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
+	}
+}
+
+/// Transaction pool adapter.
+pub struct TransactionPoolAdapter<B, E, A> where A: Send + Sync, E: Send + Sync {
+	imports_external_transactions: bool,
+	pool: Arc<TransactionPool<A>>,
+	client: Arc<Client<B, E, Block>>,
+}
+
+impl<B, E, A> TransactionPoolAdapter<B, E, A>
+	where
+		A: Send + Sync,
+		B: client::backend::Backend<Block> + Send + Sync,
+		E: client::CallExecutor<Block> + Send + Sync,
+{
+	fn best_block_id(&self) -> Option<BlockId> {
+		self.client.info()
+			.map(|info| BlockId::hash(info.chain.best_hash))
+			.map_err(|e| {
+				debug!("Error getting best block: {:?}", e);
+			})
+			.ok()
+	}
+}
+
+impl<B, E, A> network::TransactionPool<Block> for TransactionPoolAdapter<B, E, A>
+	where
+		B: client::backend::Backend<Block> + Send + Sync,
+		E: client::CallExecutor<Block> + Send + Sync,
+		A: polkadot_api::PolkadotApi + Send + Sync,
+{
+	fn transactions(&self) -> Vec<(Hash, Vec<u8>)> {
+		let best_block_id = match self.best_block_id() {
+			Some(id) => id,
+			None => return vec![],
+		};
+		self.pool.cull_and_get_pending(best_block_id, |pending| pending
+			.map(|t| {
+				let hash = t.hash().clone();
+				(hash, t.primitive_extrinsic())
+			})
+			.collect()
+		).unwrap_or_else(|e| {
+			warn!("Error retrieving pending set: {}", e);
+			vec![]
+		})
+	}
+
+	fn import(&self, transaction: &Vec<u8>) -> Option<Hash> {
+		if !self.imports_external_transactions {
+			return None;
+		}
+
+		let encoded = transaction.encode();
+		if let Some(uxt) = codec::Slicable::decode(&mut &encoded[..]) {
+			let best_block_id = self.best_block_id()?;
+			match self.pool.import_unchecked_extrinsic(best_block_id, uxt) {
+				Ok(xt) => Some(*xt.hash()),
+				Err(e) => match *e.kind() {
+					transaction_pool::ErrorKind::AlreadyImported(hash) => Some(hash[..].into()),
+					_ => {
+						debug!("Error adding transaction to the pool: {:?}", e);
+						None
+					},
+				}
+			}
+		} else {
+			debug!("Error decoding transaction");
+			None
+		}
+	}
+
+	fn on_broadcasted(&self, propagations: HashMap<Hash, Vec<String>>) {
+		self.pool.on_broadcasted(propagations)
+	}
+}
+
+impl<B, E, A> service::ExtrinsicPool<Block> for TransactionPoolAdapter<B, E, A>
+	where
+		B: client::backend::Backend<Block> + Send + Sync + 'static,
+		E: client::CallExecutor<Block> + Send + Sync + 'static,
+		A: polkadot_api::PolkadotApi + Send + Sync + 'static,
+{
+	type Api = TransactionPool<A>;
+
+	fn prune_imported(&self, hash: &Hash) {
+		let block = BlockId::hash(*hash);
+		if let Err(e) = self.pool.cull(block) {
 			warn!("Culling error: {:?}", e);
 		}
 
-	if let Err(e) = pool.retry_verification(block) {
+		if let Err(e) = self.pool.retry_verification(block) {
 			warn!("Re-verifying error: {:?}", e);
 		}
-}
-
-impl<Components> Drop for Service<Components> where Components: components::Components {
-	fn drop(&mut self) {
-		debug!(target: "service", "Polkadot service shutdown");
-
-		self.network.stop_network();
-
-		if let Some(signal) = self.signal.take() {
-			signal.fire();
 	}
+
+	fn api(&self) -> Arc<Self::Api> {
+		self.pool.clone()
 	}
 }
+

polkadot/src/main.rs

@@ -25,7 +25,7 @@ extern crate futures;
 #[macro_use]
 extern crate error_chain;
 
-use cli::{ClientError, ServiceComponents, ClientBackend, PolkadotBlock, StateMachineBackend, Service};
+use cli::{ServiceComponents, Service};
 use futures::sync::oneshot;
 use futures::{future, Future};
 
@@ -51,9 +51,7 @@ impl cli::Worker for Worker {
 		exit.map_err(drop)
 	}
 
-	fn work<C: ServiceComponents>(self, _service: &Service<C>) -> Self::Exit
-		where ClientError: From<<<<C as ServiceComponents>::Backend as ClientBackend<PolkadotBlock>>::State as StateMachineBackend>::Error>,
-	{
+	fn work<C: ServiceComponents>(self, _service: &Service<C>) -> Self::Exit {
 		self.exit_only()
 	}
 }

polkadot/transaction-pool/src/lib.rs

@@ -45,7 +45,7 @@ use std::{
 
 use codec::Slicable;
 use extrinsic_pool::{Pool, Listener, txpool::{self, Readiness, scoring::{Change, Choice}}};
-use extrinsic_pool::api::ExtrinsicPool;
+use extrinsic_pool::api::{ExtrinsicPool, EventStream};
 use polkadot_api::PolkadotApi;
 use primitives::{AccountId, BlockId, Hash, Index, UncheckedExtrinsic as FutureProofUncheckedExtrinsic};
 use runtime::{Address, UncheckedExtrinsic};
@@ -403,6 +403,14 @@ impl<A> ExtrinsicPool<FutureProofUncheckedExtrinsic, BlockId, Hash> for Transact
 			})
 			.collect()
 	}
+
+	fn light_status(&self) -> LightStatus {
+		self.inner.light_status()
+	}
+
+	fn import_notification_stream(&self) -> EventStream {
+		self.inner.import_notification_stream()
+	}
 }
 
 #[cfg(test)]