Update to latest Substrate (#407)

* Update to latest Substrate

* Fix main.rs

polkadot/service/Cargo.toml

@@ -22,6 +22,9 @@ sr-io = { git = "https://github.com/paritytech/substrate", branch = "polkadot-ma
 sr-primitives = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
 primitives = { package = "substrate-primitives", git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
 client = { package = "substrate-client", git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
+client-db = { package = "substrate-client-db", git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
+substrate-executor = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
+substrate-network = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
 consensus_common = { package = "substrate-consensus-common", git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
 grandpa = { package = "substrate-finality-grandpa", git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
 grandpa_primitives = { package = "substrate-finality-grandpa-primitives", git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }

polkadot/service/src/lib.rs

@@ -20,83 +20,46 @@ pub mod chain_spec;
 
 use futures::prelude::*;
 use client::LongestChain;
-use consensus_common::SelectChain;
 use std::sync::Arc;
 use std::time::Duration;
-use polkadot_primitives::{parachain, Block, Hash, BlockId};
-use polkadot_runtime::{GenesisConfig, RuntimeApi};
+use polkadot_primitives::{parachain, Hash, BlockId};
+use polkadot_runtime::GenesisConfig;
 use polkadot_network::{gossip::{self as network_gossip, Known}, validation::ValidationNetwork};
-use service::{
-	FactoryFullConfiguration, FullBackend, LightBackend, FullExecutor, LightExecutor,
-	error::Error as ServiceError, TelemetryOnConnect
-};
+use service::{error::{Error as ServiceError}, Configuration, ServiceBuilder};
 use transaction_pool::txpool::{Pool as TransactionPool};
-use babe::{import_queue, start_babe, BabeImportQueue, Config};
+use babe::{import_queue, start_babe, Config};
 use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
 use inherents::InherentDataProviders;
 use log::info;
-pub use service::{
-	Roles, PruningMode, TransactionPoolOptions, ComponentClient,
-	Error, ComponentBlock, LightComponents, FullComponents,
-	FullClient, LightClient, Components, Service, ServiceFactory
-};
+pub use service::{AbstractService, Roles, PruningMode, TransactionPoolOptions, Error};
+pub use service::{ServiceBuilderExport, ServiceBuilderImport, ServiceBuilderRevert};
 pub use service::config::full_version_from_strs;
-pub use client::{backend::Backend, runtime_api::Core as CoreApi, ExecutionStrategy};
+pub use client::{backend::Backend, runtime_api::{Core as CoreApi, ConstructRuntimeApi}, ExecutionStrategy, CallExecutor};
+pub use consensus_common::SelectChain;
 pub use polkadot_network::{PolkadotProtocol, NetworkService};
 pub use polkadot_primitives::parachain::{CollatorId, ParachainHost};
+pub use polkadot_primitives::Block;
+pub use polkadot_runtime::RuntimeApi;
 pub use primitives::Blake2Hasher;
 pub use sr_primitives::traits::ProvideRuntimeApi;
+pub use substrate_network::specialization::NetworkSpecialization;
 pub use chain_spec::ChainSpec;
 pub use consensus::run_validation_worker;
 
-/// All configuration for the polkadot node.
-pub type Configuration = FactoryFullConfiguration<Factory>;
-
-type BabeBlockImportForService<F> = babe::BabeBlockImport<
-	FullBackend<F>,
-	FullExecutor<F>,
-	<F as crate::ServiceFactory>::Block,
-	grandpa::BlockImportForService<F>,
-	<F as crate::ServiceFactory>::RuntimeApi,
-	client::Client<
-		FullBackend<F>,
-		FullExecutor<F>,
-		<F as crate::ServiceFactory>::Block,
-		<F as crate::ServiceFactory>::RuntimeApi
-	>,
->;
-
 /// Polkadot-specific configuration.
 pub struct CustomConfiguration {
 	/// Set to `Some` with a collator `CollatorId` and desired parachain
 	/// if the network protocol should be started in collator mode.
 	pub collating_for: Option<(CollatorId, parachain::Id)>,
 
-	/// Intermediate state during setup. Will be removed in future. Set to `None`.
-	// FIXME: rather than putting this on the config, let's have an actual intermediate setup state
-	// https://github.com/paritytech/substrate/issues/1134
-	pub import_setup: Option<(
-		BabeBlockImportForService<Factory>,
-		grandpa::LinkHalfForService<Factory>,
-		babe::BabeLink,
-	)>,
-
-	/// Tasks that were created by previous setup steps and should be spawned.
-	pub tasks_to_spawn: Option<Vec<Box<dyn Future<Item = (), Error = ()> + Send>>>,
-
 	/// Maximal `block_data` size.
 	pub max_block_data_size: Option<u64>,
-
-	inherent_data_providers: InherentDataProviders,
 }
 
 impl Default for CustomConfiguration {
 	fn default() -> Self {
 		Self {
 			collating_for: None,
-			import_setup: None,
-			inherent_data_providers: InherentDataProviders::new(),
-			tasks_to_spawn: None,
 			max_block_data_size: None,
 		}
 	}
@@ -108,305 +71,283 @@ pub type TxChainApi<Backend, Executor> = transaction_pool::ChainApi<
 	Block,
 >;
 
-/// Provides polkadot types.
-pub trait PolkadotService {
-	/// The client's backend type.
-	type Backend: 'static + client::backend::Backend<Block, Blake2Hasher>;
-	/// The client's call executor type.
-	type Executor: 'static + client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone;
+/// Starts a `ServiceBuilder` for a full service.
+///
+/// Use this macro if you don't actually need the full service, but just the builder in order to
+/// be able to perform chain operations.
+macro_rules! new_full_start {
+	($config:expr) => {{
+		let mut import_setup = None;
+		let inherent_data_providers = inherents::InherentDataProviders::new();
+		let mut tasks_to_spawn = None;
 
-	/// Get a handle to the client.
-	fn client(&self) -> Arc<client::Client<Self::Backend, Self::Executor, Block, RuntimeApi>>;
-
-	fn select_chain(&self) -> Option<client::LongestChain<Self::Backend, Block>>;
-
-	/// Get a handle to the network.
-	fn network(&self) -> Arc<NetworkService>;
-
-	/// Get a handle to the transaction pool.
-	fn transaction_pool(&self) -> Arc<TransactionPool<TxChainApi<Self::Backend, Self::Executor>>>;
-}
-
-impl PolkadotService for Service<FullComponents<Factory>> {
-	type Backend = <FullComponents<Factory> as Components>::Backend;
-	type Executor = <FullComponents<Factory> as Components>::Executor;
-
-	fn client(&self) -> Arc<client::Client<Self::Backend, Self::Executor, Block, RuntimeApi>> {
-		Service::client(self)
-	}
-
-	fn select_chain(&self) -> Option<client::LongestChain<Self::Backend, Block>> {
-		Service::select_chain(self)
-	}
-
-	fn network(&self) -> Arc<NetworkService> {
-		Service::network(self)
-	}
-
-	fn transaction_pool(&self) -> Arc<TransactionPool<TxChainApi<Self::Backend, Self::Executor>>> {
-		Service::transaction_pool(self)
-	}
-}
-
-impl PolkadotService for Service<LightComponents<Factory>> {
-	type Backend = <LightComponents<Factory> as Components>::Backend;
-	type Executor = <LightComponents<Factory> as Components>::Executor;
-
-	fn client(&self) -> Arc<client::Client<Self::Backend, Self::Executor, Block, RuntimeApi>> {
-		Service::client(self)
-	}
-
-	fn select_chain(&self) -> Option<client::LongestChain<Self::Backend, Block>> {
-		None
-	}
-
-	fn network(&self) -> Arc<NetworkService> {
-		Service::network(self)
-	}
-
-	fn transaction_pool(&self) -> Arc<TransactionPool<TxChainApi<Self::Backend, Self::Executor>>> {
-		Service::transaction_pool(self)
-	}
-}
-
-service::construct_service_factory! {
-	struct Factory {
-		Block = Block,
-		RuntimeApi = RuntimeApi,
-		NetworkProtocol = PolkadotProtocol { |config: &Configuration| Ok(PolkadotProtocol::new(config.custom.collating_for.clone())) },
-		RuntimeDispatch = polkadot_executor::Executor,
-		FullTransactionPoolApi = transaction_pool::ChainApi<client::Client<FullBackend<Self>, FullExecutor<Self>, Block, RuntimeApi>, Block>
-			{ |config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client))) },
-		LightTransactionPoolApi = transaction_pool::ChainApi<client::Client<LightBackend<Self>, LightExecutor<Self>, Block, RuntimeApi>, Block>
-			{ |config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client))) },
-		Genesis = GenesisConfig,
-		Configuration = CustomConfiguration,
-		FullService = FullComponents<Self> { |config: FactoryFullConfiguration<Self>| FullComponents::<Factory>::new(config) },
-		AuthoritySetup = {
-			|mut service: Self::FullService| {
-				let (block_import, link_half, babe_link) = service.config_mut().custom.import_setup.take()
-					.expect("Link Half and Block Import are present for Full Services or setup failed before. qed");
-
-				// spawn any futures that were created in the previous setup steps
-				if let Some(tasks) = service.config_mut().custom.tasks_to_spawn.take() {
-					for task in tasks {
-						service.spawn_task(
-							task.select(service.on_exit())
-								.map(|_| ())
-								.map_err(|_| ())
-						);
-					}
-				}
-
-				if service.config().custom.collating_for.is_some() {
-					info!(
-						"The node cannot start as an authority because it is also configured to run as a collator."
-					);
-					return Ok(service);
-				}
-
-				let client = service.client();
-				let known_oracle = client.clone();
-				let select_chain = if let Some(select_chain) = service.select_chain() {
-					select_chain
-				} else {
-					info!("The node cannot start as an authority because it can't select chain.");
-					return Ok(service);
-				};
-
-				let gossip_validator_select_chain = select_chain.clone();
-				let gossip_validator = network_gossip::register_validator(
-					service.network(),
-					move |block_hash: &Hash| {
-						use client::BlockStatus;
-
-						match known_oracle.block_status(&BlockId::hash(*block_hash)) {
-							Err(_) | Ok(BlockStatus::Unknown) | Ok(BlockStatus::Queued) => None,
-							Ok(BlockStatus::KnownBad) => Some(Known::Bad),
-							Ok(BlockStatus::InChainWithState) | Ok(BlockStatus::InChainPruned) => {
-								match gossip_validator_select_chain.leaves() {
-									Err(_) => None,
-									Ok(leaves) => if leaves.contains(block_hash) {
-										Some(Known::Leaf)
-									} else {
-										Some(Known::Old)
-									},
-								}
-							}
-						}
-					},
-				);
-
-				if service.config().roles.is_authority() {
-					let extrinsic_store = {
-						use std::path::PathBuf;
-
-						let mut path = PathBuf::from(service.config().database_path.clone());
-						path.push("availability");
-
-						av_store::Store::new(::av_store::Config {
-							cache_size: None,
-							path,
-						})?
-					};
-
-					// collator connections and validation network both fulfilled by this
-					let validation_network = ValidationNetwork::new(
-						service.network(),
-						service.on_exit(),
-						gossip_validator,
-						service.client(),
-						polkadot_network::validation::WrappedExecutor(service.spawn_task_handle()),
-					);
-					let proposer = consensus::ProposerFactory::new(
-						client.clone(),
-						select_chain.clone(),
-						validation_network.clone(),
-						validation_network,
-						service.transaction_pool(),
-						Arc::new(service.spawn_task_handle()),
-						service.keystore(),
-						extrinsic_store,
-						polkadot_runtime::constants::time::SLOT_DURATION,
-						service.config().custom.max_block_data_size,
-					);
-
-					let client = service.client();
-					let select_chain = service.select_chain().ok_or(ServiceError::SelectChainRequired)?;
-
-					let babe_config = babe::BabeParams {
-						config: Config::get_or_compute(&*client)?,
-						keystore: service.keystore(),
-						client,
-						select_chain,
-						block_import,
-						env: proposer,
-						sync_oracle: service.network(),
-						inherent_data_providers: service.config().custom.inherent_data_providers.clone(),
-						force_authoring: service.config().force_authoring,
-						time_source: babe_link,
-					};
-
-					let babe = start_babe(babe_config)?;
-					let select = babe.select(service.on_exit()).then(|_| Ok(()));
-					service.spawn_essential_task(Box::new(select));
-				} else {
-					network_gossip::register_non_authority_validator(service.network());
-				}
-
-				let config = grandpa::Config {
-					// FIXME substrate#1578 make this available through chainspec
-					gossip_duration: Duration::from_millis(333),
-					justification_period: 4096,
-					name: Some(service.config().name.clone()),
-					keystore: Some(service.keystore()),
-				};
-
-				match (service.config().roles.is_authority(), service.config().disable_grandpa) {
-					(false, false) => {
-						// start the lightweight GRANDPA observer
-						service.spawn_task(Box::new(grandpa::run_grandpa_observer(
-							config,
-							link_half,
-							service.network(),
-							service.on_exit(),
-						)?));
-					},
-					(true, false) => {
-						// start the full GRANDPA voter
-						let telemetry_on_connect = TelemetryOnConnect {
-							telemetry_connection_sinks: service.telemetry_on_connect_stream(),
-						};
-						let grandpa_config = grandpa::GrandpaParams {
-							config: config,
-							link: link_half,
-							network: service.network(),
-							inherent_data_providers: service.config().custom.inherent_data_providers.clone(),
-							on_exit: service.on_exit(),
-							telemetry_on_connect: Some(telemetry_on_connect),
-						};
-						service.spawn_essential_task(Box::new(grandpa::run_grandpa_voter(grandpa_config)?));
-					},
-					(_, true) => {
-						grandpa::setup_disabled_grandpa(
-							service.client(),
-							&service.config().custom.inherent_data_providers,
-							service.network(),
-						)?;
-					},
-				}
-
-				Ok(service)
-			}
-		},
-		LightService = LightComponents<Self>
-			{ |config| <LightComponents<Factory>>::new(config) },
-		FullImportQueue = BabeImportQueue<Self::Block>
-			{ |
-				config: &mut FactoryFullConfiguration<Self>,
-				client: Arc<FullClient<Self>>,
-				select_chain: Self::SelectChain,
-				transaction_pool: Option<Arc<TransactionPool<Self::FullTransactionPoolApi>>>
-			| {
+		let builder = service::ServiceBuilder::new_full::<
+			Block, RuntimeApi, polkadot_executor::Executor
+		>($config)?
+			.with_select_chain(|_config, client| {
+				#[allow(deprecated)]
+				Ok(client::LongestChain::new(client.backend().clone()))
+			})?
+			.with_transaction_pool(|config, client|
+				Ok(transaction_pool::txpool::Pool::new(config, transaction_pool::ChainApi::new(client)))
+			)?
+			.with_import_queue(|_config, client, mut select_chain, transaction_pool| {
+				let select_chain = select_chain.take()
+					.ok_or_else(|| service::Error::SelectChainRequired)?;
 				let (block_import, link_half) =
-					grandpa::block_import::<_, _, _, RuntimeApi, FullClient<Self>, _>(
+					grandpa::block_import::<_, _, _, RuntimeApi, _, _>(
 						client.clone(), client.clone(), select_chain
 					)?;
 				let justification_import = block_import.clone();
 
-				let (import_queue, babe_link, babe_block_import, pruning_task) = import_queue(
-					Config::get_or_compute(&*client)?,
+				let (import_queue, babe_link, babe_block_import, pruning_task) = babe::import_queue(
+					babe::Config::get_or_compute(&*client)?,
 					block_import,
 					Some(Box::new(justification_import)),
 					None,
 					client.clone(),
 					client,
-					config.custom.inherent_data_providers.clone(),
-					transaction_pool,
+					inherent_data_providers.clone(),
+					Some(transaction_pool)
 				)?;
 
-				config.custom.import_setup = Some((babe_block_import.clone(), link_half, babe_link));
-				config.custom.tasks_to_spawn = Some(vec![Box::new(pruning_task)]);
+				import_setup = Some((babe_block_import.clone(), link_half, babe_link));
+				tasks_to_spawn = Some(vec![Box::new(pruning_task)]);
 
 				Ok(import_queue)
-			}},
-		LightImportQueue = BabeImportQueue<Self::Block>
-			{ |config: &FactoryFullConfiguration<Self>, client: Arc<LightClient<Self>>| {
-				#[allow(deprecated)]
-				let fetch_checker = client.backend().blockchain().fetcher()
-					.upgrade()
-					.map(|fetcher| fetcher.checker().clone())
-					.ok_or_else(|| "Trying to start light import queue without active fetch checker")?;
-				let block_import = grandpa::light_block_import::<_, _, _, RuntimeApi, LightClient<Self>>(
-					client.clone(), Arc::new(fetch_checker), client.clone()
-				)?;
+			})?;
+		
+		(builder, import_setup, inherent_data_providers, tasks_to_spawn)
+	}}
+}
 
-				let finality_proof_import = block_import.clone();
-				let finality_proof_request_builder = finality_proof_import.create_finality_proof_request_builder();
+/// Builds a new object suitable for chain operations.
+pub fn new_chain_ops(config: Configuration<impl Send + Default + 'static, GenesisConfig>)
+	-> Result<impl ServiceBuilderExport + ServiceBuilderImport + ServiceBuilderRevert, ServiceError>
+{
+	Ok(new_full_start!(config).0)
+}
 
-				// FIXME: pruning task isn't started since light client doesn't do `AuthoritySetup`.
-				let (import_queue, ..) = import_queue::<_, _, _, _, _, _, TransactionPool<Self::FullTransactionPoolApi>>(
-					Config::get_or_compute(&*client)?,
-					block_import,
-					None,
-					Some(Box::new(finality_proof_import)),
-					client.clone(),
-					client,
-					config.custom.inherent_data_providers.clone(),
-					None,
-				)?;
+/// Builds a new service for a full client.
+pub fn new_full(config: Configuration<CustomConfiguration, GenesisConfig>)
+	-> Result<impl AbstractService<
+		Block = Block, RuntimeApi = RuntimeApi, NetworkSpecialization = PolkadotProtocol,
+		Backend = impl Backend<Block, Blake2Hasher> + 'static,
+		SelectChain = impl SelectChain<Block>,
+		CallExecutor = impl CallExecutor<Block, Blake2Hasher> + Clone + Send + Sync + 'static,
+	>, ServiceError>
+{
+	let (builder, mut import_setup, inherent_data_providers, mut tasks_to_spawn) = new_full_start!(config);
 
-				Ok((import_queue, finality_proof_request_builder))
-			}},
-		SelectChain = LongestChain<FullBackend<Self>, Self::Block>
-			{ |config: &FactoryFullConfiguration<Self>, client: Arc<FullClient<Self>>| {
-				#[allow(deprecated)]
-				Ok(LongestChain::new(client.backend().clone()))
+	let service = builder
+		.with_network_protocol(|config| Ok(PolkadotProtocol::new(config.custom.collating_for.clone())))?
+		.with_finality_proof_provider(|client|
+			Ok(Arc::new(GrandpaFinalityProofProvider::new(client.clone(), client)) as _)
+		)?
+		.build()?;
+
+	let (block_import, link_half, babe_link) = import_setup.take()
+		.expect("Link Half and Block Import are present for Full Services or setup failed before. qed");
+
+	// spawn any futures that were created in the previous setup steps
+	if let Some(tasks) = tasks_to_spawn.take() {
+		for task in tasks {
+			service.spawn_task(
+				task.select(service.on_exit())
+					.map(|_| ())
+					.map_err(|_| ())
+			);
+		}
+	}
+
+	if service.config().custom.collating_for.is_some() {
+		info!(
+			"The node cannot start as an authority because it is also configured to run as a collator."
+		);
+		return Ok(service);
+	}
+
+	let client = service.client();
+	let known_oracle = client.clone();
+	let select_chain = if let Some(select_chain) = service.select_chain() {
+		select_chain
+	} else {
+		info!("The node cannot start as an authority because it can't select chain.");
+		return Ok(service);
+	};
+
+	let gossip_validator_select_chain = select_chain.clone();
+	let gossip_validator = network_gossip::register_validator(
+		service.network(),
+		move |block_hash: &Hash| {
+			use client::BlockStatus;
+
+			match known_oracle.block_status(&BlockId::hash(*block_hash)) {
+				Err(_) | Ok(BlockStatus::Unknown) | Ok(BlockStatus::Queued) => None,
+				Ok(BlockStatus::KnownBad) => Some(Known::Bad),
+				Ok(BlockStatus::InChainWithState) | Ok(BlockStatus::InChainPruned) => {
+					match gossip_validator_select_chain.leaves() {
+						Err(_) => None,
+						Ok(leaves) => if leaves.contains(block_hash) {
+							Some(Known::Leaf)
+						} else {
+							Some(Known::Old)
+						},
+					}
+				}
 			}
 		},
-		FinalityProofProvider = { |client: Arc<FullClient<Self>>| {
-			Ok(Some(Arc::new(GrandpaFinalityProofProvider::new(client.clone(), client)) as _))
-		}},
-		RpcExtensions = (),
+	);
+
+	if service.config().roles.is_authority() {
+		let extrinsic_store = {
+			use std::path::PathBuf;
+
+			let mut path = PathBuf::from(service.config().database_path.clone());
+			path.push("availability");
+
+			av_store::Store::new(::av_store::Config {
+				cache_size: None,
+				path,
+			})?
+		};
+
+		// collator connections and validation network both fulfilled by this
+		let validation_network = ValidationNetwork::new(
+			service.network(),
+			service.on_exit(),
+			gossip_validator,
+			service.client(),
+			polkadot_network::validation::WrappedExecutor(service.spawn_task_handle()),
+		);
+		let proposer = consensus::ProposerFactory::new(
+			client.clone(),
+			select_chain.clone(),
+			validation_network.clone(),
+			validation_network,
+			service.transaction_pool(),
+			Arc::new(service.spawn_task_handle()),
+			service.keystore(),
+			extrinsic_store,
+			polkadot_runtime::constants::time::SLOT_DURATION,
+			service.config().custom.max_block_data_size,
+		);
+
+		let client = service.client();
+		let select_chain = service.select_chain().ok_or(ServiceError::SelectChainRequired)?;
+
+		let babe_config = babe::BabeParams {
+			config: Config::get_or_compute(&*client)?,
+			keystore: service.keystore(),
+			client,
+			select_chain,
+			block_import,
+			env: proposer,
+			sync_oracle: service.network(),
+			inherent_data_providers: inherent_data_providers.clone(),
+			force_authoring: service.config().force_authoring,
+			time_source: babe_link,
+		};
+
+		let babe = start_babe(babe_config)?;
+		let select = babe.select(service.on_exit()).then(|_| Ok(()));
+		service.spawn_essential_task(Box::new(select));
+	} else {
+		network_gossip::register_non_authority_validator(service.network());
 	}
+
+	let config = grandpa::Config {
+		// FIXME substrate#1578 make this available through chainspec
+		gossip_duration: Duration::from_millis(333),
+		justification_period: 4096,
+		name: Some(service.config().name.clone()),
+		keystore: Some(service.keystore()),
+	};
+
+	match (service.config().roles.is_authority(), service.config().disable_grandpa) {
+		(false, false) => {
+			// start the lightweight GRANDPA observer
+			service.spawn_task(Box::new(grandpa::run_grandpa_observer(
+				config,
+				link_half,
+				service.network(),
+				service.on_exit(),
+			)?));
+		},
+		(true, false) => {
+			// start the full GRANDPA voter
+			let grandpa_config = grandpa::GrandpaParams {
+				config: config,
+				link: link_half,
+				network: service.network(),
+				inherent_data_providers: inherent_data_providers.clone(),
+				on_exit: service.on_exit(),
+				telemetry_on_connect: Some(service.telemetry_on_connect_stream()),
+			};
+			service.spawn_essential_task(Box::new(grandpa::run_grandpa_voter(grandpa_config)?));
+		},
+		(_, true) => {
+			grandpa::setup_disabled_grandpa(
+				service.client(),
+				&inherent_data_providers,
+				service.network(),
+			)?;
+		},
+	}
+
+	Ok(service)
+}
+
+/// Builds a new service for a light client.
+pub fn new_light(config: Configuration<CustomConfiguration, GenesisConfig>)
+	-> Result<impl AbstractService<
+		Block = Block, RuntimeApi = RuntimeApi, NetworkSpecialization = PolkadotProtocol,
+		Backend = impl Backend<Block, Blake2Hasher> + 'static,
+		SelectChain = impl SelectChain<Block>,
+		CallExecutor = impl CallExecutor<Block, Blake2Hasher> + Clone + Send + Sync + 'static,
+	>, ServiceError>
+{
+	let inherent_data_providers = InherentDataProviders::new();
+
+	ServiceBuilder::new_light::<Block, RuntimeApi, polkadot_executor::Executor>(config)?
+		.with_select_chain(|_config, client| {
+			#[allow(deprecated)]
+			Ok(LongestChain::new(client.backend().clone()))
+		})?
+		.with_transaction_pool(|config, client|
+			Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
+		)?
+		.with_import_queue_and_fprb(|_config, client, _select_chain, transaction_pool| {
+			#[allow(deprecated)]
+			let fetch_checker = client.backend().blockchain().fetcher()
+				.upgrade()
+				.map(|fetcher| fetcher.checker().clone())
+				.ok_or_else(|| "Trying to start light import queue without active fetch checker")?;
+			let block_import = grandpa::light_block_import::<_, _, _, RuntimeApi, _>(
+				client.clone(), Arc::new(fetch_checker), client.clone()
+			)?;
+
+			let finality_proof_import = block_import.clone();
+			let finality_proof_request_builder =
+				finality_proof_import.create_finality_proof_request_builder();
+
+			// FIXME: pruning task isn't started since light client doesn't do `AuthoritySetup`.
+			let (import_queue, ..) = import_queue(
+				Config::get_or_compute(&*client)?,
+				block_import,
+				None,
+				Some(Box::new(finality_proof_import)),
+				client.clone(),
+				client,
+				inherent_data_providers.clone(),
+				Some(transaction_pool)
+			)?;
+
+			Ok((import_queue, finality_proof_request_builder))
+		})?
+		.with_network_protocol(|config| Ok(PolkadotProtocol::new(config.custom.collating_for.clone())))?
+		.with_finality_proof_provider(|client|
+			Ok(Arc::new(GrandpaFinalityProofProvider::new(client.clone(), client)) as _)
+		)?
+		.build()
 }