lib.rs

	let (babe_block_import, babe_link) = babe::block_import(
		babe::Config::get_or_compute(&*client)?,
		grandpa_block_import,
		client.clone(),
	)?;

	// FIXME: pruning task isn't started since light client doesn't do `AuthoritySetup`.
	let slot_duration = babe_link.config().slot_duration();
	let import_queue = babe::import_queue(
		babe_link,
		babe_block_import,
		Some(Box::new(justification_import)),
		client.clone(),
		select_chain.clone(),
		move |_, ()| async move {
			let timestamp = sp_timestamp::InherentDataProvider::from_system_time();

			let slot =
				sp_consensus_babe::inherents::InherentDataProvider::from_timestamp_and_duration(
					*timestamp,
					slot_duration,
				);

			Ok((timestamp, slot))
		},
		&task_manager.spawn_essential_handle(),
		config.prometheus_registry(),
		consensus_common::NeverCanAuthor,
		telemetry.as_ref().map(|x| x.handle()),
	)?;

	let (network, system_rpc_tx, network_starter) =
		service::build_network(service::BuildNetworkParams {
			config: &config,
			client: client.clone(),
			transaction_pool: transaction_pool.clone(),
			spawn_handle: task_manager.spawn_handle(),
			import_queue,
			on_demand: Some(on_demand.clone()),
			block_announce_validator_builder: None,
		})?;

	let enable_grandpa = !config.disable_grandpa;
	if enable_grandpa {
		let name = config.network.node_name.clone();

		let config = grandpa::Config {
			gossip_duration: Duration::from_millis(1000),
			justification_period: 512,
			name: Some(name),
			observer_enabled: false,
			keystore: None,
			local_role: config.role.clone(),
			telemetry: telemetry.as_ref().map(|x| x.handle()),
		};

		task_manager.spawn_handle().spawn_blocking(
			"grandpa-observer",
			grandpa::run_grandpa_observer(config, grandpa_link, network.clone())?,
		);
	}

	if config.offchain_worker.enabled {
		let _ = service::build_offchain_workers(
			&config,
			task_manager.spawn_handle(),
			client.clone(),
			network.clone(),
		);
	}

	let light_deps = polkadot_rpc::LightDeps {
		remote_blockchain: backend.remote_blockchain(),
		fetcher: on_demand.clone(),
		client: client.clone(),
		pool: transaction_pool.clone(),
	};

	let rpc_extensions = polkadot_rpc::create_light(light_deps);

	let rpc_handlers = service::spawn_tasks(service::SpawnTasksParams {
		on_demand: Some(on_demand),
		remote_blockchain: Some(backend.remote_blockchain()),
		rpc_extensions_builder: Box::new(service::NoopRpcExtensionBuilder(rpc_extensions)),
		task_manager: &mut task_manager,
		config,
		keystore: keystore_container.sync_keystore(),
		backend,
		transaction_pool,
		client,
		network,
		system_rpc_tx,
		telemetry: telemetry.as_mut(),
	})?;

	network_starter.start_network();

	Ok((task_manager, rpc_handlers))
}

/// Builds a new object suitable for chain operations.
#[cfg(feature = "full-node")]
pub fn new_chain_ops(
	mut config: &mut Configuration,
	jaeger_agent: Option<std::net::SocketAddr>,
) -> Result<
	(
		Arc<Client>,
		Arc<FullBackend>,
		consensus_common::import_queue::BasicQueue<Block, PrefixedMemoryDB<BlakeTwo256>>,
		TaskManager,
	),
	Error
>
{
	config.keystore = service::config::KeystoreConfig::InMemory;

	#[cfg(feature = "rococo-native")]
	if config.chain_spec.is_rococo() || config.chain_spec.is_wococo() {
		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
			= new_partial::<rococo_runtime::RuntimeApi, RococoExecutor>(config, jaeger_agent, None)?;
		return Ok((Arc::new(Client::Rococo(client)), backend, import_queue, task_manager))
	}

	#[cfg(feature = "kusama-native")]
	if config.chain_spec.is_kusama() {
		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
			= new_partial::<kusama_runtime::RuntimeApi, KusamaExecutor>(config, jaeger_agent, None)?;
		return Ok((Arc::new(Client::Kusama(client)), backend, import_queue, task_manager))
	}

	#[cfg(feature = "westend-native")]
	if config.chain_spec.is_westend() {
		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
			= new_partial::<westend_runtime::RuntimeApi, WestendExecutor>(config, jaeger_agent, None)?;
		return Ok((Arc::new(Client::Westend(client)), backend, import_queue, task_manager))
	}

	let service::PartialComponents { client, backend, import_queue, task_manager, .. }
		= new_partial::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(config, jaeger_agent, None)?;
	Ok((Arc::new(Client::Polkadot(client)), backend, import_queue, task_manager))
}


/// Build a new light node.
#[cfg(feature = "light-node")]
pub fn build_light(config: Configuration) -> Result<(
	TaskManager,
	RpcHandlers,
), Error> {
	#[cfg(feature = "rococo-native")]
	if config.chain_spec.is_rococo() || config.chain_spec.is_wococo() {
		return new_light::<rococo_runtime::RuntimeApi, RococoExecutor>(config)
	}

	#[cfg(feature = "kusama-native")]
	if config.chain_spec.is_kusama() {
		return new_light::<kusama_runtime::RuntimeApi, KusamaExecutor>(config)
	}

	#[cfg(feature = "westend-native")]
	if config.chain_spec.is_westend() {
		return new_light::<westend_runtime::RuntimeApi, WestendExecutor>(config)
	}

	new_light::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(config)
}

#[cfg(feature = "full-node")]
pub fn build_full(
	config: Configuration,
	is_collator: IsCollator,
	grandpa_pause: Option<(u32, u32)>,
	disable_beefy: bool,
	jaeger_agent: Option<std::net::SocketAddr>,
	telemetry_worker_handle: Option<TelemetryWorkerHandle>,
	overseer_gen: impl OverseerGen,
) -> Result<NewFull<Client>, Error> {
	#[cfg(feature = "rococo-native")]
	if config.chain_spec.is_rococo() || config.chain_spec.is_wococo() {
		return new_full::<rococo_runtime::RuntimeApi, RococoExecutor, _>(
			config,
			is_collator,
			grandpa_pause,
			disable_beefy,
			jaeger_agent,
			telemetry_worker_handle,
			None,
			overseer_gen,
		).map(|full| full.with_client(Client::Rococo))
	}

	#[cfg(feature = "kusama-native")]
	if config.chain_spec.is_kusama() {
		return new_full::<kusama_runtime::RuntimeApi, KusamaExecutor, _>(
			config,
			is_collator,
			grandpa_pause,
			disable_beefy,
			jaeger_agent,
			telemetry_worker_handle,
			None,
			overseer_gen,
		).map(|full| full.with_client(Client::Kusama))
	}

	#[cfg(feature = "westend-native")]
	if config.chain_spec.is_westend() {
		return new_full::<westend_runtime::RuntimeApi, WestendExecutor, _>(
			config,
			is_collator,
			grandpa_pause,
			disable_beefy,
			jaeger_agent,
			telemetry_worker_handle,
			None,
			overseer_gen,
		).map(|full| full.with_client(Client::Westend))
	}

	new_full::<polkadot_runtime::RuntimeApi, PolkadotExecutor, _>(
		config,
		is_collator,
		grandpa_pause,
		disable_beefy,
		jaeger_agent,
		telemetry_worker_handle,
		None,
		overseer_gen,
	).map(|full| full.with_client(Client::Polkadot))
}