git.delta.rocks / unique-network / refs/commits / 8691db961913

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// std18use std::sync::Arc;19use std::sync::Mutex;20use std::collections::BTreeMap;21use std::time::Duration;22use fc_rpc_core::types::FeeHistoryCache;23use futures::StreamExt;2425use unique_rpc::overrides_handle;2627use serde::{Serialize, Deserialize};2829// Cumulus Imports30use cumulus_client_consensus_aura::{AuraConsensus, BuildAuraConsensusParams, SlotProportion};31use cumulus_client_consensus_common::ParachainConsensus;32use cumulus_client_service::{33	prepare_node_config, start_collator, start_full_node, StartCollatorParams, StartFullNodeParams,34};35use cumulus_client_cli::CollatorOptions;36use cumulus_client_network::BlockAnnounceValidator;37use cumulus_primitives_core::ParaId;38use cumulus_relay_chain_inprocess_interface::build_inprocess_relay_chain;39use cumulus_relay_chain_interface::{RelayChainError, RelayChainInterface, RelayChainResult};40use cumulus_relay_chain_rpc_interface::RelayChainRPCInterface;4142// Substrate Imports43use sc_client_api::ExecutorProvider;44use sc_executor::NativeElseWasmExecutor;45use sc_executor::NativeExecutionDispatch;46use sc_network::NetworkService;47use sc_service::{BasePath, Configuration, PartialComponents, Role, TaskManager};48use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};49use sp_keystore::SyncCryptoStorePtr;50use sp_runtime::traits::BlakeTwo256;51use substrate_prometheus_endpoint::Registry;52use sc_client_api::BlockchainEvents;5354use polkadot_service::CollatorPair;5556// Frontier Imports57use fc_rpc_core::types::FilterPool;58use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};5960use unique_runtime_common::types::{AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block};6162/// Unique native executor instance.63#[cfg(feature = "unique-runtime")]64pub struct UniqueRuntimeExecutor;6566#[cfg(feature = "quartz-runtime")]67/// Quartz native executor instance.6869pub struct QuartzRuntimeExecutor;7071/// Opal native executor instance.72pub struct OpalRuntimeExecutor;7374#[cfg(feature = "unique-runtime")]75impl NativeExecutionDispatch for UniqueRuntimeExecutor {76	type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;7778	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {79		unique_runtime::api::dispatch(method, data)80	}8182	fn native_version() -> sc_executor::NativeVersion {83		unique_runtime::native_version()84	}85}8687#[cfg(feature = "quartz-runtime")]88impl NativeExecutionDispatch for QuartzRuntimeExecutor {89	type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;9091	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {92		quartz_runtime::api::dispatch(method, data)93	}9495	fn native_version() -> sc_executor::NativeVersion {96		quartz_runtime::native_version()97	}98}99100impl NativeExecutionDispatch for OpalRuntimeExecutor {101	type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;102103	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {104		opal_runtime::api::dispatch(method, data)105	}106107	fn native_version() -> sc_executor::NativeVersion {108		opal_runtime::native_version()109	}110}111112pub fn open_frontier_backend(config: &Configuration) -> Result<Arc<fc_db::Backend<Block>>, String> {113	let config_dir = config114		.base_path115		.as_ref()116		.map(|base_path| base_path.config_dir(config.chain_spec.id()))117		.unwrap_or_else(|| {118			BasePath::from_project("", "", "unique").config_dir(config.chain_spec.id())119		});120	let database_dir = config_dir.join("frontier").join("db");121122	Ok(Arc::new(fc_db::Backend::<Block>::new(123		&fc_db::DatabaseSettings {124			source: fc_db::DatabaseSettingsSrc::RocksDb {125				path: database_dir,126				cache_size: 0,127			},128		},129	)?))130}131132type FullClient<RuntimeApi, ExecutorDispatch> =133	sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<ExecutorDispatch>>;134type FullBackend = sc_service::TFullBackend<Block>;135type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;136137/// Starts a `ServiceBuilder` for a full service.138///139/// Use this macro if you don't actually need the full service, but just the builder in order to140/// be able to perform chain operations.141#[allow(clippy::type_complexity)]142pub fn new_partial<RuntimeApi, ExecutorDispatch, BIQ>(143	config: &Configuration,144	build_import_queue: BIQ,145) -> Result<146	PartialComponents<147		FullClient<RuntimeApi, ExecutorDispatch>,148		FullBackend,149		FullSelectChain,150		sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,151		sc_transaction_pool::FullPool<Block, FullClient<RuntimeApi, ExecutorDispatch>>,152		(153			Option<Telemetry>,154			Option<FilterPool>,155			Arc<fc_db::Backend<Block>>,156			Option<TelemetryWorkerHandle>,157			FeeHistoryCache,158		),159	>,160	sc_service::Error,161>162where163	sc_client_api::StateBackendFor<FullBackend, Block>: sp_api::StateBackend<BlakeTwo256>,164	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>165		+ Send166		+ Sync167		+ 'static,168	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>,169	ExecutorDispatch: NativeExecutionDispatch + 'static,170	BIQ: FnOnce(171		Arc<FullClient<RuntimeApi, ExecutorDispatch>>,172		&Configuration,173		Option<TelemetryHandle>,174		&TaskManager,175	) -> Result<176		sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,177		sc_service::Error,178	>,179{180	let _telemetry = config181		.telemetry_endpoints182		.clone()183		.filter(|x| !x.is_empty())184		.map(|endpoints| -> Result<_, sc_telemetry::Error> {185			let worker = TelemetryWorker::new(16)?;186			let telemetry = worker.handle().new_telemetry(endpoints);187			Ok((worker, telemetry))188		})189		.transpose()?;190191	let telemetry = config192		.telemetry_endpoints193		.clone()194		.filter(|x| !x.is_empty())195		.map(|endpoints| -> Result<_, sc_telemetry::Error> {196			let worker = TelemetryWorker::new(16)?;197			let telemetry = worker.handle().new_telemetry(endpoints);198			Ok((worker, telemetry))199		})200		.transpose()?;201202	let executor = NativeElseWasmExecutor::<ExecutorDispatch>::new(203		config.wasm_method,204		config.default_heap_pages,205		config.max_runtime_instances,206		config.runtime_cache_size,207	);208209	let (client, backend, keystore_container, task_manager) =210		sc_service::new_full_parts::<Block, RuntimeApi, _>(211			config,212			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),213			executor,214		)?;215	let client = Arc::new(client);216217	let telemetry_worker_handle = telemetry.as_ref().map(|(worker, _)| worker.handle());218219	let telemetry = telemetry.map(|(worker, telemetry)| {220		task_manager221			.spawn_handle()222			.spawn("telemetry", None, worker.run());223		telemetry224	});225226	let select_chain = sc_consensus::LongestChain::new(backend.clone());227228	let transaction_pool = sc_transaction_pool::BasicPool::new_full(229		config.transaction_pool.clone(),230		config.role.is_authority().into(),231		config.prometheus_registry(),232		task_manager.spawn_essential_handle(),233		client.clone(),234	);235236	let filter_pool: Option<FilterPool> = Some(Arc::new(Mutex::new(BTreeMap::new())));237238	let frontier_backend = open_frontier_backend(config)?;239240	let import_queue = build_import_queue(241		client.clone(),242		config,243		telemetry.as_ref().map(|telemetry| telemetry.handle()),244		&task_manager,245	)?;246	let fee_history_cache: FeeHistoryCache = Arc::new(Mutex::new(BTreeMap::new()));247248	let params = PartialComponents {249		backend,250		client,251		import_queue,252		keystore_container,253		task_manager,254		transaction_pool,255		select_chain,256		other: (257			telemetry,258			filter_pool,259			frontier_backend,260			telemetry_worker_handle,261			fee_history_cache,262		),263	};264265	Ok(params)266}267268async fn build_relay_chain_interface(269	polkadot_config: Configuration,270	parachain_config: &Configuration,271	telemetry_worker_handle: Option<TelemetryWorkerHandle>,272	task_manager: &mut TaskManager,273	collator_options: CollatorOptions,274) -> RelayChainResult<(275	Arc<(dyn RelayChainInterface + 'static)>,276	Option<CollatorPair>,277)> {278	match collator_options.relay_chain_rpc_url {279		Some(relay_chain_url) => Ok((280			Arc::new(RelayChainRPCInterface::new(relay_chain_url).await?) as Arc<_>,281			None,282		)),283		None => build_inprocess_relay_chain(284			polkadot_config,285			parachain_config,286			telemetry_worker_handle,287			task_manager,288		),289	}290}291292/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.293///294/// This is the actual implementation that is abstract over the executor and the runtime api.295#[sc_tracing::logging::prefix_logs_with("Parachain")]296async fn start_node_impl<Runtime, RuntimeApi, ExecutorDispatch, BIQ, BIC>(297	parachain_config: Configuration,298	polkadot_config: Configuration,299	collator_options: CollatorOptions,300	id: ParaId,301	build_import_queue: BIQ,302	build_consensus: BIC,303) -> sc_service::error::Result<(TaskManager, Arc<FullClient<RuntimeApi, ExecutorDispatch>>)>304where305	sc_client_api::StateBackendFor<FullBackend, Block>: sp_api::StateBackend<BlakeTwo256>,306	Runtime: RuntimeInstance + Send + Sync + 'static,307	<Runtime as RuntimeInstance>::CrossAccountId: Serialize,308	for<'de> <Runtime as RuntimeInstance>::CrossAccountId: Deserialize<'de>,309	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>310		+ Send311		+ Sync312		+ 'static,313	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>314		+ fp_rpc::EthereumRuntimeRPCApi<Block>315		+ sp_session::SessionKeys<Block>316		+ sp_block_builder::BlockBuilder<Block>317		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>318		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>319		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>320		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>321		+ sp_api::Metadata<Block>322		+ sp_offchain::OffchainWorkerApi<Block>323		+ cumulus_primitives_core::CollectCollationInfo<Block>,324	ExecutorDispatch: NativeExecutionDispatch + 'static,325	BIQ: FnOnce(326		Arc<FullClient<RuntimeApi, ExecutorDispatch>>,327		&Configuration,328		Option<TelemetryHandle>,329		&TaskManager,330	) -> Result<331		sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,332		sc_service::Error,333	>,334	BIC: FnOnce(335		Arc<FullClient<RuntimeApi, ExecutorDispatch>>,336		Option<&Registry>,337		Option<TelemetryHandle>,338		&TaskManager,339		Arc<dyn RelayChainInterface>,340		Arc<sc_transaction_pool::FullPool<Block, FullClient<RuntimeApi, ExecutorDispatch>>>,341		Arc<NetworkService<Block, Hash>>,342		SyncCryptoStorePtr,343		bool,344	) -> Result<Box<dyn ParachainConsensus<Block>>, sc_service::Error>,345{346	if matches!(parachain_config.role, Role::Light) {347		return Err("Light client not supported!".into());348	}349350	let parachain_config = prepare_node_config(parachain_config);351352	let params =353		new_partial::<RuntimeApi, ExecutorDispatch, BIQ>(&parachain_config, build_import_queue)?;354	let (mut telemetry, filter_pool, frontier_backend, telemetry_worker_handle, fee_history_cache) =355		params.other;356357	let client = params.client.clone();358	let backend = params.backend.clone();359	let mut task_manager = params.task_manager;360361	let (relay_chain_interface, collator_key) = build_relay_chain_interface(362		polkadot_config,363		&parachain_config,364		telemetry_worker_handle,365		&mut task_manager,366		collator_options.clone(),367	)368	.await369	.map_err(|e| match e {370		RelayChainError::ServiceError(polkadot_service::Error::Sub(x)) => x,371		s => s.to_string().into(),372	})?;373374	let block_announce_validator = BlockAnnounceValidator::new(relay_chain_interface.clone(), id);375376	let force_authoring = parachain_config.force_authoring;377	let validator = parachain_config.role.is_authority();378	let prometheus_registry = parachain_config.prometheus_registry().cloned();379	let transaction_pool = params.transaction_pool.clone();380	let import_queue = cumulus_client_service::SharedImportQueue::new(params.import_queue);381382	let (network, system_rpc_tx, start_network) =383		sc_service::build_network(sc_service::BuildNetworkParams {384			config: &parachain_config,385			client: client.clone(),386			transaction_pool: transaction_pool.clone(),387			spawn_handle: task_manager.spawn_handle(),388			import_queue: import_queue.clone(),389			block_announce_validator_builder: Some(Box::new(|_| {390				Box::new(block_announce_validator)391			})),392			warp_sync: None,393		})?;394395	let subscription_executor = sc_rpc::SubscriptionTaskExecutor::new(task_manager.spawn_handle());396	let rpc_client = client.clone();397	let rpc_pool = transaction_pool.clone();398	let select_chain = params.select_chain.clone();399	let rpc_network = network.clone();400401	let rpc_frontier_backend = frontier_backend.clone();402403	let block_data_cache = Arc::new(fc_rpc::EthBlockDataCache::new(404		task_manager.spawn_handle(),405		overrides_handle::<_, _, Runtime>(client.clone()),406		50,407		50,408	));409410	let rpc_extensions_builder = Box::new(move |deny_unsafe, _| {411		let full_deps = unique_rpc::FullDeps {412			backend: rpc_frontier_backend.clone(),413			deny_unsafe,414			client: rpc_client.clone(),415			pool: rpc_pool.clone(),416			graph: rpc_pool.pool().clone(),417			// TODO: Unhardcode418			enable_dev_signer: false,419			filter_pool: filter_pool.clone(),420			network: rpc_network.clone(),421			select_chain: select_chain.clone(),422			is_authority: validator,423			// TODO: Unhardcode424			max_past_logs: 10000,425			block_data_cache: block_data_cache.clone(),426			fee_history_cache: fee_history_cache.clone(),427			// TODO: Unhardcode428			fee_history_limit: 2048,429		};430431		Ok(432			unique_rpc::create_full::<_, _, _, _, Runtime, RuntimeApi, _>(433				full_deps,434				subscription_executor.clone(),435			),436		)437	});438439	task_manager.spawn_essential_handle().spawn(440		"frontier-mapping-sync-worker",441		None,442		MappingSyncWorker::new(443			client.import_notification_stream(),444			Duration::new(6, 0),445			client.clone(),446			backend.clone(),447			frontier_backend.clone(),448			SyncStrategy::Normal,449		)450		.for_each(|()| futures::future::ready(())),451	);452453	sc_service::spawn_tasks(sc_service::SpawnTasksParams {454		rpc_extensions_builder,455		client: client.clone(),456		transaction_pool: transaction_pool.clone(),457		task_manager: &mut task_manager,458		config: parachain_config,459		keystore: params.keystore_container.sync_keystore(),460		backend: backend.clone(),461		network: network.clone(),462		system_rpc_tx,463		telemetry: telemetry.as_mut(),464	})?;465466	let announce_block = {467		let network = network.clone();468		Arc::new(move |hash, data| network.announce_block(hash, data))469	};470471	let relay_chain_slot_duration = Duration::from_secs(6);472473	if validator {474		let parachain_consensus = build_consensus(475			client.clone(),476			prometheus_registry.as_ref(),477			telemetry.as_ref().map(|t| t.handle()),478			&task_manager,479			relay_chain_interface.clone(),480			transaction_pool,481			network,482			params.keystore_container.sync_keystore(),483			force_authoring,484		)?;485486		let spawner = task_manager.spawn_handle();487488		let params = StartCollatorParams {489			para_id: id,490			block_status: client.clone(),491			announce_block,492			client: client.clone(),493			task_manager: &mut task_manager,494			spawner,495			parachain_consensus,496			import_queue,497			collator_key: collator_key.expect("Command line arguments do not allow this. qed"),498			relay_chain_interface,499			relay_chain_slot_duration,500		};501502		start_collator(params).await?;503	} else {504		let params = StartFullNodeParams {505			client: client.clone(),506			announce_block,507			task_manager: &mut task_manager,508			para_id: id,509			import_queue,510			relay_chain_interface,511			relay_chain_slot_duration,512			collator_options,513		};514515		start_full_node(params)?;516	}517518	start_network.start_network();519520	Ok((task_manager, client))521}522523/// Build the import queue for the the parachain runtime.524pub fn parachain_build_import_queue<RuntimeApi, ExecutorDispatch>(525	client: Arc<FullClient<RuntimeApi, ExecutorDispatch>>,526	config: &Configuration,527	telemetry: Option<TelemetryHandle>,528	task_manager: &TaskManager,529) -> Result<530	sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,531	sc_service::Error,532>533where534	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>535		+ Send536		+ Sync537		+ 'static,538	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>539		+ sp_block_builder::BlockBuilder<Block>540		+ sp_consensus_aura::AuraApi<Block, AuraId>541		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>,542	ExecutorDispatch: NativeExecutionDispatch + 'static,543{544	let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;545546	cumulus_client_consensus_aura::import_queue::<547		sp_consensus_aura::sr25519::AuthorityPair,548		_,549		_,550		_,551		_,552		_,553		_,554	>(cumulus_client_consensus_aura::ImportQueueParams {555		block_import: client.clone(),556		client: client.clone(),557		create_inherent_data_providers: move |_, _| async move {558			let time = sp_timestamp::InherentDataProvider::from_system_time();559560			let slot =561				sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(562					*time,563					slot_duration,564				);565566			Ok((time, slot))567		},568		registry: config.prometheus_registry(),569		can_author_with: sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),570		spawner: &task_manager.spawn_essential_handle(),571		telemetry,572	})573	.map_err(Into::into)574}575576/// Start a normal parachain node.577pub async fn start_node<Runtime, RuntimeApi, ExecutorDispatch>(578	parachain_config: Configuration,579	polkadot_config: Configuration,580	collator_options: CollatorOptions,581	id: ParaId,582) -> sc_service::error::Result<(TaskManager, Arc<FullClient<RuntimeApi, ExecutorDispatch>>)>583where584	Runtime: RuntimeInstance + Send + Sync + 'static,585	<Runtime as RuntimeInstance>::CrossAccountId: Serialize,586	for<'de> <Runtime as RuntimeInstance>::CrossAccountId: Deserialize<'de>,587	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>588		+ Send589		+ Sync590		+ 'static,591	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>592		+ fp_rpc::EthereumRuntimeRPCApi<Block>593		+ sp_session::SessionKeys<Block>594		+ sp_block_builder::BlockBuilder<Block>595		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>596		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>597		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>598		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>599		+ sp_api::Metadata<Block>600		+ sp_offchain::OffchainWorkerApi<Block>601		+ cumulus_primitives_core::CollectCollationInfo<Block>602		+ sp_consensus_aura::AuraApi<Block, AuraId>,603	ExecutorDispatch: NativeExecutionDispatch + 'static,604{605	start_node_impl::<Runtime, RuntimeApi, ExecutorDispatch, _, _>(606		parachain_config,607		polkadot_config,608		collator_options,609		id,610		parachain_build_import_queue,611		|client,612		 prometheus_registry,613		 telemetry,614		 task_manager,615		 relay_chain_interface,616		 transaction_pool,617		 sync_oracle,618		 keystore,619		 force_authoring| {620			let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;621622			let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording(623				task_manager.spawn_handle(),624				client.clone(),625				transaction_pool,626				prometheus_registry,627				telemetry.clone(),628			);629630			Ok(AuraConsensus::build::<631				sp_consensus_aura::sr25519::AuthorityPair,632				_,633				_,634				_,635				_,636				_,637				_,638			>(BuildAuraConsensusParams {639				proposer_factory,640				create_inherent_data_providers: move |_, (relay_parent, validation_data)| {641					let relay_chain_interface = relay_chain_interface.clone();642					async move {643						let parachain_inherent =644						cumulus_primitives_parachain_inherent::ParachainInherentData::create_at(645							relay_parent,646							&relay_chain_interface,647							&validation_data,648							id,649						).await;650651						let time = sp_timestamp::InherentDataProvider::from_system_time();652653						let slot =654						sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(655							*time,656							slot_duration,657						);658659						let parachain_inherent = parachain_inherent.ok_or_else(|| {660							Box::<dyn std::error::Error + Send + Sync>::from(661								"Failed to create parachain inherent",662							)663						})?;664						Ok((time, slot, parachain_inherent))665					}666				},667				block_import: client.clone(),668				para_client: client,669				backoff_authoring_blocks: Option::<()>::None,670				sync_oracle,671				keystore,672				force_authoring,673				slot_duration,674				// We got around 500ms for proposing675				block_proposal_slot_portion: SlotProportion::new(1f32 / 24f32),676				telemetry,677				max_block_proposal_slot_portion: None,678			}))679		},680	)681	.await682}683684fn dev_build_import_queue<RuntimeApi, ExecutorDispatch>(685	client: Arc<FullClient<RuntimeApi, ExecutorDispatch>>,686	config: &Configuration,687	_: Option<TelemetryHandle>,688	task_manager: &TaskManager,689) -> Result<690	sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,691	sc_service::Error,692>693where694	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>695		+ Send696		+ Sync697		+ 'static,698	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>699		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>,700	ExecutorDispatch: NativeExecutionDispatch + 'static,701{702	Ok(sc_consensus_manual_seal::import_queue(703		Box::new(client.clone()),704		&task_manager.spawn_essential_handle(),705		config.prometheus_registry(),706	))707}708709/// Builds a new development service. This service uses instant seal, and mocks710/// the parachain inherent711pub fn start_dev_node<Runtime, RuntimeApi, ExecutorDispatch>(712	config: Configuration,713) -> sc_service::error::Result<TaskManager>714where715	Runtime: RuntimeInstance + Send + Sync + 'static,716	<Runtime as RuntimeInstance>::CrossAccountId: Serialize,717	for<'de> <Runtime as RuntimeInstance>::CrossAccountId: Deserialize<'de>,718	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>719		+ Send720		+ Sync721		+ 'static,722	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>723		+ fp_rpc::EthereumRuntimeRPCApi<Block>724		+ sp_session::SessionKeys<Block>725		+ sp_block_builder::BlockBuilder<Block>726		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>727		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>728		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>729		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>730		+ sp_api::Metadata<Block>731		+ sp_offchain::OffchainWorkerApi<Block>732		+ cumulus_primitives_core::CollectCollationInfo<Block>733		+ sp_consensus_aura::AuraApi<Block, AuraId>,734	ExecutorDispatch: NativeExecutionDispatch + 'static,735{736	use futures::Stream;737	use sc_consensus_manual_seal::{run_manual_seal, EngineCommand, ManualSealParams};738	use fc_consensus::FrontierBlockImport;739	use sc_client_api::HeaderBackend;740741	let sc_service::PartialComponents {742		client,743		backend,744		mut task_manager,745		import_queue,746		keystore_container,747		select_chain: maybe_select_chain,748		transaction_pool,749		other:750			(telemetry, filter_pool, frontier_backend, _telemetry_worker_handle, fee_history_cache),751	} = new_partial::<RuntimeApi, ExecutorDispatch, _>(752		&config,753		dev_build_import_queue::<RuntimeApi, ExecutorDispatch>,754	)?;755756	let block_data_cache = Arc::new(fc_rpc::EthBlockDataCache::new(757		task_manager.spawn_handle(),758		overrides_handle::<_, _, Runtime>(client.clone()),759		50,760		50,761	));762763	let (network, system_rpc_tx, network_starter) =764		sc_service::build_network(sc_service::BuildNetworkParams {765			config: &config,766			client: client.clone(),767			transaction_pool: transaction_pool.clone(),768			spawn_handle: task_manager.spawn_handle(),769			import_queue,770			block_announce_validator_builder: None,771			warp_sync: None,772		})?;773774	if config.offchain_worker.enabled {775		sc_service::build_offchain_workers(776			&config,777			task_manager.spawn_handle(),778			client.clone(),779			network.clone(),780		);781	}782783	let prometheus_registry = config.prometheus_registry().cloned();784	let collator = config.role.is_authority();785786	let select_chain = maybe_select_chain.clone();787788	if collator {789		let block_import =790			FrontierBlockImport::new(client.clone(), client.clone(), frontier_backend.clone());791792		let env = sc_basic_authorship::ProposerFactory::new(793			task_manager.spawn_handle(),794			client.clone(),795			transaction_pool.clone(),796			prometheus_registry.as_ref(),797			telemetry.as_ref().map(|x| x.handle()),798		);799800		let commands_stream: Box<dyn Stream<Item = EngineCommand<Hash>> + Send + Sync + Unpin> =801			Box::new(802				// This bit cribbed from the implementation of instant seal.803				transaction_pool804					.pool()805					.validated_pool()806					.import_notification_stream()807					.map(|_| EngineCommand::SealNewBlock {808						create_empty: true, // was false in Moonbeam809						finalize: false,810						parent_hash: None,811						sender: None,812					}),813			);814815		let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;816		let client_set_aside_for_cidp = client.clone();817818		task_manager.spawn_essential_handle().spawn_blocking(819			"authorship_task",820			Some("block-authoring"),821			run_manual_seal(ManualSealParams {822				block_import,823				env,824				client: client.clone(),825				pool: transaction_pool.clone(),826				commands_stream,827				select_chain: select_chain.clone(),828				consensus_data_provider: None,829				create_inherent_data_providers: move |block: Hash, ()| {830					let current_para_block = client_set_aside_for_cidp831						.number(block)832						.expect("Header lookup should succeed")833						.expect("Header passed in as parent should be present in backend.");834835					let client_for_xcm = client_set_aside_for_cidp.clone();836					async move {837						let time = sp_timestamp::InherentDataProvider::from_system_time();838839						let mocked_parachain = cumulus_primitives_parachain_inherent::MockValidationDataInherentDataProvider {840							current_para_block,841							relay_offset: 1000,842							relay_blocks_per_para_block: 2,843							xcm_config: cumulus_primitives_parachain_inherent::MockXcmConfig::new(844								&*client_for_xcm,845								block,846								Default::default(),847								Default::default(),848							),849							raw_downward_messages: vec![],850							raw_horizontal_messages: vec![],851						};852853						let slot =854						sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(855							*time,856							slot_duration,857						);858859						Ok((time, slot, mocked_parachain))860					}861				},862			}),863		);864	}865866	task_manager.spawn_essential_handle().spawn(867		"frontier-mapping-sync-worker",868		Some("block-authoring"),869		MappingSyncWorker::new(870			client.import_notification_stream(),871			Duration::new(6, 0),872			client.clone(),873			backend.clone(),874			frontier_backend.clone(),875			SyncStrategy::Normal,876		)877		.for_each(|()| futures::future::ready(())),878	);879880	let subscription_executor = sc_rpc::SubscriptionTaskExecutor::new(task_manager.spawn_handle());881	let rpc_client = client.clone();882	let rpc_pool = transaction_pool.clone();883	let rpc_network = network.clone();884	let rpc_frontier_backend = frontier_backend.clone();885	let rpc_extensions_builder = Box::new(move |deny_unsafe, _| {886		let full_deps = unique_rpc::FullDeps {887			backend: rpc_frontier_backend.clone(),888			deny_unsafe,889			client: rpc_client.clone(),890			pool: rpc_pool.clone(),891			graph: rpc_pool.pool().clone(),892			// TODO: Unhardcode893			enable_dev_signer: false,894			filter_pool: filter_pool.clone(),895			network: rpc_network.clone(),896			select_chain: select_chain.clone(),897			is_authority: collator,898			// TODO: Unhardcode899			max_past_logs: 10000,900			block_data_cache: block_data_cache.clone(),901			fee_history_cache: fee_history_cache.clone(),902			// TODO: Unhardcode903			fee_history_limit: 2048,904		};905906		Ok(907			unique_rpc::create_full::<_, _, _, _, Runtime, RuntimeApi, _>(908				full_deps,909				subscription_executor.clone(),910			),911		)912	});913914	sc_service::spawn_tasks(sc_service::SpawnTasksParams {915		network,916		client,917		keystore: keystore_container.sync_keystore(),918		task_manager: &mut task_manager,919		transaction_pool,920		rpc_extensions_builder,921		backend,922		system_rpc_tx,923		config,924		telemetry: None,925	})?;926927	network_starter.start_network();928	Ok(task_manager)929}