git.delta.rocks / unique-network / refs/commits / e6ed5f4e38db

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::{19	collections::BTreeMap,20	marker::PhantomData,21	pin::Pin,22	sync::{Arc, Mutex},23	time::Duration,24};2526use cumulus_client_cli::CollatorOptions;27use cumulus_client_collator::service::CollatorService;28#[cfg(not(feature = "lookahead"))]29use cumulus_client_consensus_aura::collators::basic::{30	run as run_aura, Params as BuildAuraConsensusParams,31};32#[cfg(feature = "lookahead")]33use cumulus_client_consensus_aura::collators::lookahead::{34	run as run_aura, Params as BuildAuraConsensusParams,35};36use cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport;37use cumulus_client_consensus_proposer::Proposer;38use cumulus_client_service::{39	build_relay_chain_interface, prepare_node_config, start_relay_chain_tasks, DARecoveryProfile,40	StartRelayChainTasksParams,41};42use cumulus_primitives_core::ParaId;43use cumulus_primitives_parachain_inherent::ParachainInherentData;44use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};45use fc_mapping_sync::{kv::MappingSyncWorker, EthereumBlockNotificationSinks, SyncStrategy};46use fc_rpc::{47	frontier_backend_client::SystemAccountId32StorageOverride, EthBlockDataCacheTask, EthConfig,48	EthTask, OverrideHandle, RuntimeApiStorageOverride, SchemaV1Override, SchemaV2Override,49	SchemaV3Override, StorageOverride,50};51use fc_rpc_core::types::{FeeHistoryCache, FilterPool};52use fp_rpc::EthereumRuntimeRPCApi;53use fp_storage::EthereumStorageSchema;54use futures::{55	stream::select,56	task::{Context, Poll},57	Stream, StreamExt,58};59use jsonrpsee::RpcModule;60use polkadot_service::CollatorPair;61use sc_client_api::{AuxStore, Backend, BlockOf, BlockchainEvents, StorageProvider};62use sc_consensus::ImportQueue;63use sc_executor::{NativeElseWasmExecutor, NativeExecutionDispatch};64use sc_network::NetworkBlock;65use sc_network_sync::SyncingService;66use sc_rpc::SubscriptionTaskExecutor;67use sc_service::{Configuration, PartialComponents, TaskManager};68use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};69use serde::{Deserialize, Serialize};70use sp_api::ProvideRuntimeApi;71use sp_block_builder::BlockBuilder;72use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};73use sp_consensus_aura::sr25519::AuthorityPair as AuraAuthorityPair;74use sp_keystore::KeystorePtr;75use sp_state_machine::Backend as StateBackend;76use substrate_prometheus_endpoint::Registry;77use tokio::time::Interval;78use up_common::types::{opaque::*, Nonce};7980pub type ParachainHostFunctions = (81	sp_io::SubstrateHostFunctions,82	cumulus_client_service::storage_proof_size::HostFunctions,83);8485use cumulus_primitives_core::PersistedValidationData;86use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;8788use crate::{89	chain_spec::RuntimeIdentification,90	rpc::{create_eth, create_full, EthDeps, FullDeps},91};9293/// Unique native executor instance.94#[cfg(feature = "unique-runtime")]95pub struct UniqueRuntimeExecutor;9697#[cfg(feature = "quartz-runtime")]98/// Quartz native executor instance.99pub struct QuartzRuntimeExecutor;100101/// Opal native executor instance.102pub struct OpalRuntimeExecutor;103104#[cfg(feature = "unique-runtime")]105impl NativeExecutionDispatch for UniqueRuntimeExecutor {106	/// Only enable the benchmarking host functions when we actually want to benchmark.107	#[cfg(feature = "runtime-benchmarks")]108	type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;109	/// Otherwise we only use the default Substrate host functions.110	#[cfg(not(feature = "runtime-benchmarks"))]111	type ExtendHostFunctions = ParachainHostFunctions;112113	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {114		unique_runtime::api::dispatch(method, data)115	}116117	fn native_version() -> sc_executor::NativeVersion {118		unique_runtime::native_version()119	}120}121122#[cfg(feature = "quartz-runtime")]123impl NativeExecutionDispatch for QuartzRuntimeExecutor {124	/// Only enable the benchmarking host functions when we actually want to benchmark.125	#[cfg(feature = "runtime-benchmarks")]126	type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;127	/// Otherwise we only use the default Substrate host functions.128	#[cfg(not(feature = "runtime-benchmarks"))]129	type ExtendHostFunctions = ParachainHostFunctions;130131	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {132		quartz_runtime::api::dispatch(method, data)133	}134135	fn native_version() -> sc_executor::NativeVersion {136		quartz_runtime::native_version()137	}138}139140impl NativeExecutionDispatch for OpalRuntimeExecutor {141	/// Only enable the benchmarking host functions when we actually want to benchmark.142	#[cfg(feature = "runtime-benchmarks")]143	type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;144	/// Otherwise we only use the default Substrate host functions.145	#[cfg(not(feature = "runtime-benchmarks"))]146	type ExtendHostFunctions = ParachainHostFunctions;147148	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {149		opal_runtime::api::dispatch(method, data)150	}151152	fn native_version() -> sc_executor::NativeVersion {153		opal_runtime::native_version()154	}155}156157pub struct AutosealInterval {158	interval: Interval,159}160161impl AutosealInterval {162	pub fn new(config: &Configuration, interval: u64) -> Self {163		let _tokio_runtime = config.tokio_handle.enter();164		let interval = tokio::time::interval(Duration::from_millis(interval));165166		Self { interval }167	}168}169170impl Stream for AutosealInterval {171	type Item = tokio::time::Instant;172173	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {174		self.interval.poll_tick(cx).map(Some)175	}176}177178pub fn open_frontier_backend<C: HeaderBackend<Block>>(179	client: Arc<C>,180	config: &Configuration,181) -> Result<Arc<fc_db::kv::Backend<Block>>, String> {182	let config_dir = config.base_path.config_dir(config.chain_spec.id());183	let database_dir = config_dir.join("frontier").join("db");184185	Ok(Arc::new(fc_db::kv::Backend::<Block>::new(186		client,187		&fc_db::kv::DatabaseSettings {188			source: fc_db::DatabaseSource::RocksDb {189				path: database_dir,190				cache_size: 0,191			},192		},193	)?))194}195196type FullClient<RuntimeApi, ExecutorDispatch> =197	sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<ExecutorDispatch>>;198type FullBackend = sc_service::TFullBackend<Block>;199type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;200type ParachainBlockImport<RuntimeApi, ExecutorDispatch> =201	TParachainBlockImport<Block, Arc<FullClient<RuntimeApi, ExecutorDispatch>>, FullBackend>;202203/// Generate a supertrait based on bounds, and blanket impl for it.204macro_rules! ez_bounds {205	($vis:vis trait $name:ident$(<$($gen:ident $(: $($(+)? $bound:path)*)?),* $(,)?>)? $(:)? $($(+)? $super:path)* {}) => {206		$vis trait $name $(<$($gen $(: $($bound+)*)?,)*>)?: $($super +)* {}207		impl<T, $($($gen $(: $($bound+)*)?,)*)?> $name$(<$($gen,)*>)? for T208		where T: $($super +)* {}209	}210}211ez_bounds!(212	pub trait RuntimeApiDep<Runtime: RuntimeInstance>:213		sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>214		+ sp_consensus_aura::AuraApi<Block, AuraId>215		+ fp_rpc::EthereumRuntimeRPCApi<Block>216		+ sp_session::SessionKeys<Block>217		+ sp_block_builder::BlockBuilder<Block>218		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>219		+ sp_api::ApiExt<Block>220		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>221		+ app_promotion_rpc::AppPromotionApi<Block, BlockNumber, Runtime::CrossAccountId, AccountId>222		+ up_pov_estimate_rpc::PovEstimateApi<Block>223		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>224		+ sp_api::Metadata<Block>225		+ sp_offchain::OffchainWorkerApi<Block>226		+ cumulus_primitives_core::CollectCollationInfo<Block>227		// Deprecated, not used.228		+ fp_rpc::ConvertTransactionRuntimeApi<Block>229	{230	}231);232#[cfg(not(feature = "lookahead"))]233ez_bounds!(234	pub trait LookaheadApiDep {}235);236#[cfg(feature = "lookahead")]237ez_bounds!(238	pub trait LookaheadApiDep: cumulus_primitives_aura::AuraUnincludedSegmentApi<Block> {}239);240241fn ethereum_parachain_inherent() -> (sp_timestamp::InherentDataProvider, ParachainInherentData) {242	let (relay_parent_storage_root, relay_chain_state) =243		RelayStateSproofBuilder::default().into_state_root_and_proof();244	let vfp = PersistedValidationData {245		// This is a hack to make `cumulus_pallet_parachain_system::RelayNumberStrictlyIncreases`246		// happy. Relay parent number can't be bigger than u32::MAX.247		relay_parent_number: u32::MAX,248		relay_parent_storage_root,249		..Default::default()250	};251252	(253		sp_timestamp::InherentDataProvider::from_system_time(),254		ParachainInherentData {255			validation_data: vfp,256			relay_chain_state,257			downward_messages: Default::default(),258			horizontal_messages: Default::default(),259		},260	)261}262263/// Starts a `ServiceBuilder` for a full service.264///265/// Use this macro if you don't actually need the full service, but just the builder in order to266/// be able to perform chain operations.267#[allow(clippy::type_complexity)]268pub fn new_partial<Runtime, RuntimeApi, ExecutorDispatch, BIQ>(269	config: &Configuration,270	build_import_queue: BIQ,271) -> Result<272	PartialComponents<273		FullClient<RuntimeApi, ExecutorDispatch>,274		FullBackend,275		FullSelectChain,276		sc_consensus::DefaultImportQueue<Block>,277		sc_transaction_pool::FullPool<Block, FullClient<RuntimeApi, ExecutorDispatch>>,278		OtherPartial,279	>,280	sc_service::Error,281>282where283	sc_client_api::StateBackendFor<FullBackend, Block>: StateBackend<BlakeTwo256>,284	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>285		+ Send286		+ Sync287		+ 'static,288	RuntimeApi::RuntimeApi: RuntimeApiDep<Runtime> + 'static,289	Runtime: RuntimeInstance,290	ExecutorDispatch: NativeExecutionDispatch + 'static,291	BIQ: FnOnce(292		Arc<FullClient<RuntimeApi, ExecutorDispatch>>,293		Arc<FullBackend>,294		&Configuration,295		Option<TelemetryHandle>,296		&TaskManager,297	) -> Result<sc_consensus::DefaultImportQueue<Block>, sc_service::Error>,298{299	let telemetry = config300		.telemetry_endpoints301		.clone()302		.filter(|x| !x.is_empty())303		.map(|endpoints| -> Result<_, sc_telemetry::Error> {304			let worker = TelemetryWorker::new(16)?;305			let telemetry = worker.handle().new_telemetry(endpoints);306			Ok((worker, telemetry))307		})308		.transpose()?;309310	let executor = sc_service::new_native_or_wasm_executor(config);311312	let (client, backend, keystore_container, task_manager) =313		sc_service::new_full_parts::<Block, RuntimeApi, _>(314			config,315			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),316			executor,317		)?;318	let client = Arc::new(client);319320	let telemetry_worker_handle = telemetry.as_ref().map(|(worker, _)| worker.handle());321322	let telemetry = telemetry.map(|(worker, telemetry)| {323		task_manager324			.spawn_handle()325			.spawn("telemetry", None, worker.run());326		telemetry327	});328329	let select_chain = sc_consensus::LongestChain::new(backend.clone());330331	let transaction_pool = sc_transaction_pool::BasicPool::new_full(332		config.transaction_pool.clone(),333		config.role.is_authority().into(),334		config.prometheus_registry(),335		task_manager.spawn_essential_handle(),336		client.clone(),337	);338339	let eth_filter_pool: Option<FilterPool> = Some(Arc::new(Mutex::new(BTreeMap::new())));340341	let eth_backend = open_frontier_backend(client.clone(), config)?;342343	let import_queue = build_import_queue(344		client.clone(),345		backend.clone(),346		config,347		telemetry.as_ref().map(|telemetry| telemetry.handle()),348		&task_manager,349	)?;350351	let params = PartialComponents {352		backend,353		client,354		import_queue,355		keystore_container,356		task_manager,357		transaction_pool,358		select_chain,359		other: OtherPartial {360			telemetry,361			eth_filter_pool,362			eth_backend,363			telemetry_worker_handle,364		},365	};366367	Ok(params)368}369370macro_rules! clone {371    ($($i:ident),* $(,)?) => {372		$(373			let $i = $i.clone();374		)*375    };376}377378/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.379///380/// This is the actual implementation that is abstract over the executor and the runtime api.381#[sc_tracing::logging::prefix_logs_with("Parachain")]382pub async fn start_node<Runtime, RuntimeApi, ExecutorDispatch>(383	parachain_config: Configuration,384	polkadot_config: Configuration,385	collator_options: CollatorOptions,386	para_id: ParaId,387	hwbench: Option<sc_sysinfo::HwBench>,388) -> sc_service::error::Result<(TaskManager, Arc<FullClient<RuntimeApi, ExecutorDispatch>>)>389where390	sc_client_api::StateBackendFor<FullBackend, Block>: StateBackend<BlakeTwo256>,391	Runtime: RuntimeInstance + Send + Sync + 'static,392	<Runtime as RuntimeInstance>::CrossAccountId: Serialize,393	for<'de> <Runtime as RuntimeInstance>::CrossAccountId: Deserialize<'de>,394	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>395		+ Send396		+ Sync397		+ 'static,398	RuntimeApi::RuntimeApi: RuntimeApiDep<Runtime> + 'static,399	RuntimeApi::RuntimeApi: LookaheadApiDep,400	Runtime: RuntimeInstance,401	ExecutorDispatch: NativeExecutionDispatch + 'static,402{403	let parachain_config = prepare_node_config(parachain_config);404405	let params = new_partial::<Runtime, RuntimeApi, ExecutorDispatch, _>(406		&parachain_config,407		parachain_build_import_queue,408	)?;409	let OtherPartial {410		mut telemetry,411		telemetry_worker_handle,412		eth_filter_pool,413		eth_backend,414	} = params.other;415	let net_config = sc_network::config::FullNetworkConfiguration::new(&parachain_config.network);416417	let client = params.client.clone();418	let backend = params.backend.clone();419	let mut task_manager = params.task_manager;420421	let (relay_chain_interface, collator_key) = build_relay_chain_interface(422		polkadot_config,423		&parachain_config,424		telemetry_worker_handle,425		&mut task_manager,426		collator_options.clone(),427		hwbench.clone(),428	)429	.await430	.map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?;431432	// Aura is sybil-resistant, collator-selection is generally too.433	let block_announce_validator =434		cumulus_client_network::AssumeSybilResistance::allow_seconded_messages();435436	let validator = parachain_config.role.is_authority();437	let prometheus_registry = parachain_config.prometheus_registry().cloned();438	let transaction_pool = params.transaction_pool.clone();439	let import_queue_service = params.import_queue.service();440441	let (network, system_rpc_tx, tx_handler_controller, start_network, sync_service) =442		sc_service::build_network(sc_service::BuildNetworkParams {443			config: &parachain_config,444			net_config,445			client: client.clone(),446			transaction_pool: transaction_pool.clone(),447			spawn_handle: task_manager.spawn_handle(),448			import_queue: params.import_queue,449			block_announce_validator_builder: Some(Box::new(|_| {450				Box::new(block_announce_validator)451			})),452			warp_sync_params: None,453			block_relay: None,454		})?;455456	let select_chain = params.select_chain.clone();457458	let runtime_id = parachain_config.chain_spec.runtime_id();459460	// Frontier461	let fee_history_cache: FeeHistoryCache = Arc::new(Mutex::new(BTreeMap::new()));462	let fee_history_limit = 2048;463464	let eth_pubsub_notification_sinks: Arc<465		EthereumBlockNotificationSinks<fc_mapping_sync::EthereumBlockNotification<Block>>,466	> = Default::default();467468	let overrides = overrides_handle(client.clone());469	let eth_block_data_cache = spawn_frontier_tasks(470		FrontierTaskParams {471			client: client.clone(),472			substrate_backend: backend.clone(),473			eth_filter_pool: eth_filter_pool.clone(),474			eth_backend: eth_backend.clone(),475			fee_history_limit,476			fee_history_cache: fee_history_cache.clone(),477			task_manager: &task_manager,478			prometheus_registry: prometheus_registry.clone(),479			overrides: overrides.clone(),480			sync_strategy: SyncStrategy::Parachain,481		},482		sync_service.clone(),483		eth_pubsub_notification_sinks.clone(),484	);485486	// Rpc487	let rpc_builder = Box::new({488		clone!(489			client,490			backend,491			eth_backend,492			eth_pubsub_notification_sinks,493			fee_history_cache,494			eth_block_data_cache,495			overrides,496			transaction_pool,497			network,498			sync_service,499		);500		move |deny_unsafe, subscription_task_executor: SubscriptionTaskExecutor| {501			clone!(502				backend,503				eth_block_data_cache,504				client,505				eth_backend,506				eth_filter_pool,507				eth_pubsub_notification_sinks,508				fee_history_cache,509				eth_block_data_cache,510				network,511				runtime_id,512				transaction_pool,513				select_chain,514				overrides,515			);516517			#[cfg(not(feature = "pov-estimate"))]518			let _ = backend;519520			let mut rpc_handle = RpcModule::new(());521522			let full_deps = FullDeps {523				client: client.clone(),524				runtime_id,525526				#[cfg(feature = "pov-estimate")]527				exec_params: uc_rpc::pov_estimate::ExecutorParams {528					wasm_method: parachain_config.wasm_method,529					default_heap_pages: parachain_config.default_heap_pages,530					max_runtime_instances: parachain_config.max_runtime_instances,531					runtime_cache_size: parachain_config.runtime_cache_size,532				},533534				#[cfg(feature = "pov-estimate")]535				backend,536537				deny_unsafe,538				pool: transaction_pool.clone(),539				select_chain,540			};541542			create_full::<_, _, _, Runtime, _>(&mut rpc_handle, full_deps)?;543544			let eth_deps = EthDeps {545				client,546				graph: transaction_pool.pool().clone(),547				pool: transaction_pool,548				is_authority: validator,549				network,550				eth_backend,551				// TODO: Unhardcode552				max_past_logs: 10000,553				fee_history_limit,554				fee_history_cache,555				eth_block_data_cache,556				// TODO: Unhardcode557				enable_dev_signer: false,558				eth_filter_pool,559				eth_pubsub_notification_sinks,560				overrides,561				sync: sync_service.clone(),562				pending_create_inherent_data_providers: |_, ()| async move {563					Ok(ethereum_parachain_inherent())564				},565			};566567			create_eth::<568				_,569				_,570				_,571				_,572				_,573				_,574				DefaultEthConfig<FullClient<RuntimeApi, ExecutorDispatch>>,575			>(576				&mut rpc_handle,577				eth_deps,578				subscription_task_executor.clone(),579			)?;580581			Ok(rpc_handle)582		}583	});584585	sc_service::spawn_tasks(sc_service::SpawnTasksParams {586		rpc_builder,587		client: client.clone(),588		transaction_pool: transaction_pool.clone(),589		task_manager: &mut task_manager,590		config: parachain_config,591		keystore: params.keystore_container.keystore(),592		backend: backend.clone(),593		network,594		sync_service: sync_service.clone(),595		system_rpc_tx,596		telemetry: telemetry.as_mut(),597		tx_handler_controller,598	})?;599600	if let Some(hwbench) = hwbench {601		sc_sysinfo::print_hwbench(&hwbench);602603		if let Some(ref mut telemetry) = telemetry {604			let telemetry_handle = telemetry.handle();605			task_manager.spawn_handle().spawn(606				"telemetry_hwbench",607				None,608				sc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench),609			);610		}611	}612613	let announce_block = {614		let sync_service = sync_service.clone();615		Arc::new(Box::new(move |hash, data| {616			sync_service.announce_block(hash, data)617		}))618	};619620	let relay_chain_slot_duration = Duration::from_secs(6);621622	let overseer_handle = relay_chain_interface623		.overseer_handle()624		.map_err(|e| sc_service::Error::Application(Box::new(e)))?;625626	start_relay_chain_tasks(StartRelayChainTasksParams {627		client: client.clone(),628		announce_block: announce_block.clone(),629		para_id,630		relay_chain_interface: relay_chain_interface.clone(),631		task_manager: &mut task_manager,632		da_recovery_profile: if validator {633			DARecoveryProfile::Collator634		} else {635			DARecoveryProfile::FullNode636		},637		import_queue: import_queue_service,638		relay_chain_slot_duration,639		recovery_handle: Box::new(overseer_handle.clone()),640		sync_service: sync_service.clone(),641	})?;642643	if validator {644		start_consensus(645			client.clone(),646			transaction_pool,647			StartConsensusParameters {648				backend: backend.clone(),649				prometheus_registry: prometheus_registry.as_ref(),650				telemetry: telemetry.as_ref().map(|t| t.handle()),651				task_manager: &task_manager,652				relay_chain_interface: relay_chain_interface.clone(),653				sync_oracle: sync_service,654				keystore: params.keystore_container.keystore(),655				overseer_handle,656				relay_chain_slot_duration,657				para_id,658				collator_key: collator_key.expect("cli args do not allow this"),659				announce_block,660			},661		)?;662	}663664	start_network.start_network();665666	Ok((task_manager, client))667}668669/// Build the import queue for the the parachain runtime.670pub fn parachain_build_import_queue<Runtime, RuntimeApi, ExecutorDispatch>(671	client: Arc<FullClient<RuntimeApi, ExecutorDispatch>>,672	backend: Arc<FullBackend>,673	config: &Configuration,674	telemetry: Option<TelemetryHandle>,675	task_manager: &TaskManager,676) -> Result<sc_consensus::DefaultImportQueue<Block>, sc_service::Error>677where678	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>679		+ Send680		+ Sync681		+ 'static,682	RuntimeApi::RuntimeApi: RuntimeApiDep<Runtime> + 'static,683	Runtime: RuntimeInstance,684	ExecutorDispatch: NativeExecutionDispatch + 'static,685{686	let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;687688	let block_import = ParachainBlockImport::new(client.clone(), backend);689690	cumulus_client_consensus_aura::import_queue::<691		sp_consensus_aura::sr25519::AuthorityPair,692		_,693		_,694		_,695		_,696		_,697	>(cumulus_client_consensus_aura::ImportQueueParams {698		block_import,699		client,700		create_inherent_data_providers: move |_, _| async move {701			let time = sp_timestamp::InherentDataProvider::from_system_time();702703			let slot =704				sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(705					*time,706					slot_duration,707				);708709			Ok((slot, time))710		},711		registry: config.prometheus_registry(),712		spawner: &task_manager.spawn_essential_handle(),713		telemetry,714	})715	.map_err(Into::into)716}717718pub struct StartConsensusParameters<'a> {719	backend: Arc<FullBackend>,720	prometheus_registry: Option<&'a Registry>,721	telemetry: Option<TelemetryHandle>,722	task_manager: &'a TaskManager,723	relay_chain_interface: Arc<dyn RelayChainInterface>,724	sync_oracle: Arc<SyncingService<Block>>,725	keystore: KeystorePtr,726	overseer_handle: OverseerHandle,727	relay_chain_slot_duration: Duration,728	para_id: ParaId,729	collator_key: CollatorPair,730	announce_block: Arc<dyn Fn(Hash, Option<Vec<u8>>) + Send + Sync>,731}732733// Clones ignored for optional lookahead collator734#[allow(clippy::redundant_clone)]735pub fn start_consensus<ExecutorDispatch, RuntimeApi, Runtime>(736	client: Arc<FullClient<RuntimeApi, ExecutorDispatch>>,737	transaction_pool: Arc<738		sc_transaction_pool::FullPool<Block, FullClient<RuntimeApi, ExecutorDispatch>>,739	>,740	parameters: StartConsensusParameters<'_>,741) -> Result<(), sc_service::Error>742where743	ExecutorDispatch: NativeExecutionDispatch + 'static,744	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>745		+ Send746		+ Sync747		+ 'static,748	RuntimeApi::RuntimeApi: RuntimeApiDep<Runtime> + 'static,749	RuntimeApi::RuntimeApi: LookaheadApiDep,750	Runtime: RuntimeInstance,751{752	let StartConsensusParameters {753		backend,754		prometheus_registry,755		telemetry,756		task_manager,757		relay_chain_interface,758		sync_oracle,759		keystore,760		overseer_handle,761		relay_chain_slot_duration,762		para_id,763		collator_key,764		announce_block,765	} = parameters;766	let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;767768	let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording(769		task_manager.spawn_handle(),770		client.clone(),771		transaction_pool,772		prometheus_registry,773		telemetry,774	);775	let proposer = Proposer::new(proposer_factory);776777	let collator_service = CollatorService::new(778		client.clone(),779		Arc::new(task_manager.spawn_handle()),780		announce_block,781		client.clone(),782	);783784	let block_import = ParachainBlockImport::new(client.clone(), backend.clone());785786	let params = BuildAuraConsensusParams {787		create_inherent_data_providers: move |_, ()| async move { Ok(()) },788		block_import,789		para_client: client.clone(),790		#[cfg(feature = "lookahead")]791		para_backend: backend,792		para_id,793		relay_client: relay_chain_interface,794		sync_oracle,795		keystore,796		#[cfg(not(feature = "lookahead"))]797		slot_duration,798		proposer,799		collator_service,800		// With async-baking, we allowed to be both slower (longer authoring) and faster (multiple para blocks per relay block)801		#[cfg(not(feature = "lookahead"))]802		authoring_duration: Duration::from_millis(500),803		#[cfg(feature = "lookahead")]804		authoring_duration: Duration::from_millis(1500),805		overseer_handle,806		#[cfg(feature = "lookahead")]807		code_hash_provider: move |block_hash| {808			client809				.code_at(block_hash)810				.ok()811				.map(cumulus_primitives_core::relay_chain::ValidationCode)812				.map(|c| c.hash())813		},814		collator_key,815		relay_chain_slot_duration,816		#[cfg(not(feature = "lookahead"))]817		collation_request_receiver: None,818		#[cfg(feature = "lookahead")]819		reinitialize: false,820	};821822	task_manager.spawn_essential_handle().spawn(823		"aura",824		None,825		#[cfg(not(feature = "lookahead"))]826		run_aura::<_, AuraAuthorityPair, _, _, _, _, _, _, _>(params),827		#[cfg(feature = "lookahead")]828		run_aura::<_, AuraAuthorityPair, _, _, _, _, _, _, _, _, _>(params),829	);830	Ok(())831}832833fn dev_build_import_queue<RuntimeApi, ExecutorDispatch>(834	client: Arc<FullClient<RuntimeApi, ExecutorDispatch>>,835	_: Arc<FullBackend>,836	config: &Configuration,837	_: Option<TelemetryHandle>,838	task_manager: &TaskManager,839) -> Result<sc_consensus::DefaultImportQueue<Block>, sc_service::Error>840where841	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>842		+ Send843		+ Sync844		+ 'static,845	RuntimeApi::RuntimeApi:846		sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> + sp_api::ApiExt<Block>,847	ExecutorDispatch: NativeExecutionDispatch + 'static,848{849	Ok(sc_consensus_manual_seal::import_queue(850		Box::new(client),851		&task_manager.spawn_essential_handle(),852		config.prometheus_registry(),853	))854}855856pub struct OtherPartial {857	pub telemetry: Option<Telemetry>,858	pub telemetry_worker_handle: Option<TelemetryWorkerHandle>,859	pub eth_filter_pool: Option<FilterPool>,860	pub eth_backend: Arc<fc_db::kv::Backend<Block>>,861}862863struct DefaultEthConfig<C>(PhantomData<C>);864impl<C> EthConfig<Block, C> for DefaultEthConfig<C>865where866	C: StorageProvider<Block, FullBackend> + Sync + Send + 'static,867{868	type EstimateGasAdapter = ();869	type RuntimeStorageOverride = SystemAccountId32StorageOverride<Block, C, FullBackend>;870}871872/// Builds a new development service. This service uses instant seal, and mocks873/// the parachain inherent874pub fn start_dev_node<Runtime, RuntimeApi, ExecutorDispatch>(875	config: Configuration,876	autoseal_interval: u64,877	autoseal_finalize_delay: Option<u64>,878	disable_autoseal_on_tx: bool,879) -> sc_service::error::Result<TaskManager>880where881	Runtime: RuntimeInstance + Send + Sync + 'static,882	<Runtime as RuntimeInstance>::CrossAccountId: Serialize,883	for<'de> <Runtime as RuntimeInstance>::CrossAccountId: Deserialize<'de>,884	RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>885		+ Send886		+ Sync887		+ 'static,888	RuntimeApi::RuntimeApi: RuntimeApiDep<Runtime> + 'static,889	ExecutorDispatch: NativeExecutionDispatch + 'static,890{891	use fc_consensus::FrontierBlockImport;892	use sc_consensus_manual_seal::{893		run_delayed_finalize, run_manual_seal, DelayedFinalizeParams, EngineCommand,894		ManualSealParams,895	};896897	let sc_service::PartialComponents {898		client,899		backend,900		mut task_manager,901		import_queue,902		keystore_container,903		select_chain: maybe_select_chain,904		transaction_pool,905		other:906			OtherPartial {907				telemetry,908				eth_filter_pool,909				eth_backend,910				telemetry_worker_handle: _,911			},912	} = new_partial::<Runtime, RuntimeApi, ExecutorDispatch, _>(913		&config,914		dev_build_import_queue::<RuntimeApi, ExecutorDispatch>,915	)?;916	let net_config = sc_network::config::FullNetworkConfiguration::new(&config.network);917	let prometheus_registry = config.prometheus_registry().cloned();918919	let (network, system_rpc_tx, tx_handler_controller, network_starter, sync_service) =920		sc_service::build_network(sc_service::BuildNetworkParams {921			config: &config,922			net_config,923			client: client.clone(),924			transaction_pool: transaction_pool.clone(),925			spawn_handle: task_manager.spawn_handle(),926			import_queue,927			block_announce_validator_builder: None,928			warp_sync_params: None,929			block_relay: None,930		})?;931932	let collator = config.role.is_authority();933934	let select_chain = maybe_select_chain;935936	if collator {937		let block_import = FrontierBlockImport::new(client.clone(), client.clone());938939		let env = sc_basic_authorship::ProposerFactory::new(940			task_manager.spawn_handle(),941			client.clone(),942			transaction_pool.clone(),943			prometheus_registry.as_ref(),944			telemetry.as_ref().map(|x| x.handle()),945		);946947		let transactions_commands_stream: Box<948			dyn Stream<Item = EngineCommand<Hash>> + Send + Sync + Unpin,949		> = Box::new(950			transaction_pool951				.pool()952				.validated_pool()953				.import_notification_stream()954				.filter(move |_| futures::future::ready(!disable_autoseal_on_tx))955				.map(|_| EngineCommand::SealNewBlock {956					create_empty: true,957					finalize: false,958					parent_hash: None,959					sender: None,960				}),961		);962963		let autoseal_interval = Box::pin(AutosealInterval::new(&config, autoseal_interval));964965		let idle_commands_stream: Box<966			dyn Stream<Item = EngineCommand<Hash>> + Send + Sync + Unpin,967		> = Box::new(autoseal_interval.map(|_| EngineCommand::SealNewBlock {968			create_empty: true,969			finalize: false,970			parent_hash: None,971			sender: None,972		}));973974		let commands_stream = select(transactions_commands_stream, idle_commands_stream);975976		let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;977		let client_set_aside_for_cidp = client.clone();978979		if let Some(delay_sec) = autoseal_finalize_delay {980			let spawn_handle = task_manager.spawn_handle();981982			task_manager.spawn_essential_handle().spawn_blocking(983				"finalization_task",984				Some("block-authoring"),985				run_delayed_finalize(DelayedFinalizeParams {986					client: client.clone(),987					delay_sec,988					spawn_handle,989				}),990			);991		}992993		task_manager.spawn_essential_handle().spawn_blocking(994			"authorship_task",995			Some("block-authoring"),996			run_manual_seal(ManualSealParams {997				block_import,998				env,999				client: client.clone(),1000				pool: transaction_pool.clone(),1001				commands_stream,1002				select_chain: select_chain.clone(),1003				consensus_data_provider: None,1004				create_inherent_data_providers: move |block: Hash, ()| {1005					let current_para_block = client_set_aside_for_cidp1006						.number(block)1007						.expect("Header lookup should succeed")1008						.expect("Header passed in as parent should be present in backend.");10091010					let client_for_xcm = client_set_aside_for_cidp.clone();1011					async move {1012						let time = sp_timestamp::InherentDataProvider::from_system_time();10131014						let mocked_parachain = cumulus_client_parachain_inherent::MockValidationDataInherentDataProvider {1015							current_para_block,1016							relay_offset: 1000,1017							relay_blocks_per_para_block: 2,1018							para_blocks_per_relay_epoch: 0,1019							xcm_config: cumulus_client_parachain_inherent::MockXcmConfig::new(1020								&*client_for_xcm,1021								block,1022								Default::default(),1023								Default::default(),1024							),1025							relay_randomness_config: (),1026							raw_downward_messages: vec![],1027							raw_horizontal_messages: vec![],1028							additional_key_values: None,1029						};10301031						let slot =1032						sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(1033							*time,1034							slot_duration,1035						);10361037						Ok((time, slot, mocked_parachain))1038					}1039				},1040			}),1041		);1042	}10431044	#[cfg(feature = "pov-estimate")]1045	let rpc_backend = backend.clone();10461047	let runtime_id = config.chain_spec.runtime_id();10481049	// Frontier1050	let fee_history_cache: FeeHistoryCache = Arc::new(Mutex::new(BTreeMap::new()));1051	let fee_history_limit = 2048;10521053	let eth_pubsub_notification_sinks: Arc<1054		EthereumBlockNotificationSinks<fc_mapping_sync::EthereumBlockNotification<Block>>,1055	> = Default::default();10561057	let overrides = overrides_handle(client.clone());1058	let eth_block_data_cache = spawn_frontier_tasks(1059		FrontierTaskParams {1060			client: client.clone(),1061			substrate_backend: backend.clone(),1062			eth_filter_pool: eth_filter_pool.clone(),1063			eth_backend: eth_backend.clone(),1064			fee_history_limit,1065			fee_history_cache: fee_history_cache.clone(),1066			task_manager: &task_manager,1067			prometheus_registry,1068			overrides: overrides.clone(),1069			sync_strategy: SyncStrategy::Normal,1070		},1071		sync_service.clone(),1072		eth_pubsub_notification_sinks.clone(),1073	);10741075	// Rpc1076	let rpc_builder = Box::new({1077		clone!(1078			client,1079			backend,1080			eth_backend,1081			eth_pubsub_notification_sinks,1082			fee_history_cache,1083			eth_block_data_cache,1084			overrides,1085			transaction_pool,1086			network,1087			sync_service,1088		);1089		move |deny_unsafe, subscription_task_executor: SubscriptionTaskExecutor| {1090			clone!(1091				backend,1092				eth_block_data_cache,1093				client,1094				eth_backend,1095				eth_filter_pool,1096				eth_pubsub_notification_sinks,1097				fee_history_cache,1098				eth_block_data_cache,1099				network,1100				runtime_id,1101				transaction_pool,1102				select_chain,1103				overrides,1104			);11051106			#[cfg(not(feature = "pov-estimate"))]1107			let _ = backend;11081109			let mut rpc_module = RpcModule::new(());11101111			let full_deps = FullDeps {1112				runtime_id,11131114				#[cfg(feature = "pov-estimate")]1115				exec_params: uc_rpc::pov_estimate::ExecutorParams {1116					wasm_method: config.wasm_method,1117					default_heap_pages: config.default_heap_pages,1118					max_runtime_instances: config.max_runtime_instances,1119					runtime_cache_size: config.runtime_cache_size,1120				},11211122				#[cfg(feature = "pov-estimate")]1123				backend,1124				// eth_backend,1125				deny_unsafe,1126				client: client.clone(),1127				pool: transaction_pool.clone(),1128				select_chain,1129			};11301131			create_full::<_, _, _, Runtime, _>(&mut rpc_module, full_deps)?;11321133			let eth_deps = EthDeps {1134				client,1135				graph: transaction_pool.pool().clone(),1136				pool: transaction_pool,1137				is_authority: true,1138				network,1139				eth_backend,1140				// TODO: Unhardcode1141				max_past_logs: 10000,1142				fee_history_limit,1143				fee_history_cache,1144				eth_block_data_cache,1145				// TODO: Unhardcode1146				enable_dev_signer: false,1147				eth_filter_pool,1148				eth_pubsub_notification_sinks,1149				overrides,1150				sync: sync_service.clone(),1151				// We don't have any inherents except parachain built-ins, which we can't even extract from inside `run_aura`.1152				pending_create_inherent_data_providers: |_, ()| async move {1153					Ok(ethereum_parachain_inherent())1154				},1155			};11561157			create_eth::<1158				_,1159				_,1160				_,1161				_,1162				_,1163				_,1164				DefaultEthConfig<FullClient<RuntimeApi, ExecutorDispatch>>,1165			>(1166				&mut rpc_module,1167				eth_deps,1168				subscription_task_executor.clone(),1169			)?;11701171			Ok(rpc_module)1172		}1173	});11741175	sc_service::spawn_tasks(sc_service::SpawnTasksParams {1176		network,1177		sync_service,1178		client,1179		keystore: keystore_container.keystore(),1180		task_manager: &mut task_manager,1181		transaction_pool,1182		rpc_builder,1183		backend,1184		system_rpc_tx,1185		config,1186		telemetry: None,1187		tx_handler_controller,1188	})?;11891190	network_starter.start_network();1191	Ok(task_manager)1192}11931194fn overrides_handle<C, BE>(client: Arc<C>) -> Arc<OverrideHandle<Block>>1195where1196	C: ProvideRuntimeApi<Block> + StorageProvider<Block, BE> + AuxStore,1197	C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError>,1198	C: Send + Sync + 'static,1199	C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,1200	BE: Backend<Block> + 'static,1201	BE::State: StateBackend<BlakeTwo256>,1202{1203	let mut overrides_map = BTreeMap::new();1204	overrides_map.insert(1205		EthereumStorageSchema::V1,1206		Box::new(SchemaV1Override::new(client.clone())) as Box<dyn StorageOverride<_> + 'static>,1207	);1208	overrides_map.insert(1209		EthereumStorageSchema::V2,1210		Box::new(SchemaV2Override::new(client.clone())) as Box<dyn StorageOverride<_> + 'static>,1211	);1212	overrides_map.insert(1213		EthereumStorageSchema::V3,1214		Box::new(SchemaV3Override::new(client.clone())) as Box<dyn StorageOverride<_> + 'static>,1215	);12161217	Arc::new(OverrideHandle {1218		schemas: overrides_map,1219		fallback: Box::new(RuntimeApiStorageOverride::new(client)),1220	})1221}12221223pub struct FrontierTaskParams<'a, C, B> {1224	pub task_manager: &'a TaskManager,1225	pub client: Arc<C>,1226	pub substrate_backend: Arc<B>,1227	pub eth_backend: Arc<fc_db::kv::Backend<Block>>,1228	pub eth_filter_pool: Option<FilterPool>,1229	pub overrides: Arc<OverrideHandle<Block>>,1230	pub fee_history_limit: u64,1231	pub fee_history_cache: FeeHistoryCache,1232	pub sync_strategy: SyncStrategy,1233	pub prometheus_registry: Option<Registry>,1234}12351236pub fn spawn_frontier_tasks<C, B>(1237	params: FrontierTaskParams<C, B>,1238	sync: Arc<SyncingService<Block>>,1239	pubsub_notification_sinks: Arc<1240		EthereumBlockNotificationSinks<fc_mapping_sync::EthereumBlockNotification<Block>>,1241	>,1242) -> Arc<EthBlockDataCacheTask<Block>>1243where1244	C: ProvideRuntimeApi<Block> + BlockOf,1245	C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError> + 'static,1246	C: BlockchainEvents<Block> + StorageProvider<Block, B>,1247	C: Send + Sync + 'static,1248	C::Api: EthereumRuntimeRPCApi<Block>,1249	C::Api: BlockBuilder<Block>,1250	B: Backend<Block> + 'static,1251	B::State: StateBackend<BlakeTwo256>,1252{1253	let FrontierTaskParams {1254		task_manager,1255		client,1256		substrate_backend,1257		eth_backend,1258		eth_filter_pool,1259		overrides,1260		fee_history_limit,1261		fee_history_cache,1262		sync_strategy,1263		prometheus_registry,1264	} = params;1265	// Frontier offchain DB task. Essential.1266	// Maps emulated ethereum data to substrate native data.1267	params.task_manager.spawn_essential_handle().spawn(1268		"frontier-mapping-sync-worker",1269		Some("frontier"),1270		MappingSyncWorker::new(1271			client.import_notification_stream(),1272			Duration::new(6, 0),1273			client.clone(),1274			substrate_backend,1275			overrides.clone(),1276			eth_backend,1277			3,1278			0,1279			sync_strategy,1280			sync,1281			pubsub_notification_sinks,1282		)1283		.for_each(|()| futures::future::ready(())),1284	);12851286	// Frontier `EthFilterApi` maintenance.1287	// Manages the pool of user-created Filters.1288	if let Some(eth_filter_pool) = eth_filter_pool {1289		// Each filter is allowed to stay in the pool for 100 blocks.1290		const FILTER_RETAIN_THRESHOLD: u64 = 100;1291		params.task_manager.spawn_essential_handle().spawn(1292			"frontier-filter-pool",1293			Some("frontier"),1294			EthTask::filter_pool_task(client.clone(), eth_filter_pool, FILTER_RETAIN_THRESHOLD),1295		);1296	}12971298	// Spawn Frontier FeeHistory cache maintenance task.1299	params.task_manager.spawn_essential_handle().spawn(1300		"frontier-fee-history",1301		Some("frontier"),1302		EthTask::fee_history_task(1303			client,1304			overrides.clone(),1305			fee_history_cache,1306			fee_history_limit,1307		),1308	);13091310	Arc::new(EthBlockDataCacheTask::new(1311		task_manager.spawn_handle(),1312		overrides,1313		50,1314		50,1315		prometheus_registry,1316	))1317}