fn create_dev_rpc_extension<C, P>(

    DevDeps {

        client,

        pool,

        chain_spec,

        deny_unsafe,

        command_sink: maybe_command_sink,

    }: DevDeps<C, P>,

) -> Result<RpcExtension, Box<dyn std::error::Error + Send + Sync>>

where

    C: ProvideRuntimeApi<Block>

        + HeaderBackend<Block>

        + AuxStore

        + HeaderMetadata<Block, Error = sp_blockchain::Error>

        + Send

        + Sync

        + 'static,

    C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,

    C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,

    C::Api: BlockBuilder<Block>,

    P: TransactionPool + Sync + Send + 'static,

{

    let mut io = RpcModule::new(());

    let chain_name = chain_spec.name().to_string();

    let genesis_hash = client

        .hash(0)

        .ok()

        .flatten()

        .expect("Genesis block exists; qed");

    let properties = chain_spec.properties();

    io.merge(ChainSpec::new(chain_name, genesis_hash, properties).into_rpc())?;

    io.merge(System::new(client.clone(), pool.clone(), deny_unsafe).into_rpc())?;

    io.merge(TransactionPayment::new(client.clone()).into_rpc())?;

    if let Some(command_sink) = maybe_command_sink {

        io.merge(ManualSeal::new(command_sink).into_rpc())?;

    Ok(io)

}

    pub fn new(client: Arc<C>, parent: Hash) -> Self {

        EmptyParachainsInherentDataProvider { client, parent }

    }

    pub async fn create(

        client: Arc<C>,

        parent: Hash,

    ) -> Result<ParachainsInherentData, InherentError> {

        let parent_header = match client.header(parent) {

            Ok(Some(h)) => h,

        Ok(ParachainsInherentData {

            bitfields: Vec::new(),

            backed_candidates: Vec::new(),

            disputes: Vec::new(),

            parent_header,

        })

    }

    ) -> Result<(), sp_inherents::Error> {

        let inherent_data =

            EmptyParachainsInherentDataProvider::create(self.client.clone(), self.parent)

                .map_err(|e| sp_inherents::Error::Application(Box::new(e)))?;

        dst_inherent_data.put_data(

            polkadot_primitives::PARACHAINS_INHERENT_IDENTIFIER,

            &inherent_data,

        )

    }

pub fn build_full<OverseerGenerator: OverseerGen>(

    sealing: Sealing,

    config: Configuration,

    mut params: NewFullParams<OverseerGenerator>,

) -> Result<NewFull, Error> {

    let is_polkadot = config.chain_spec.is_polkadot();

    params.overseer_message_channel_capacity_override = params

        .overseer_message_channel_capacity_override

        .map(move |capacity| {

        });

    match config.network.network_backend {

            new_full::<_, sc_network::NetworkWorker<Block, Hash>>(sealing, config, params)

}

fn get_next_timestamp(

    client: Arc<FullClient>,

    slot_duration: SlotDuration,

) -> sp_timestamp::InherentDataProvider {

    let maybe_last_timestamp = client

        .get_aux(TIMESTAMP_AUX_KEY)

        .expect("Should be able to query aux storage; qed");

    if let Some(last_timestamp) = maybe_last_timestamp {

        let last_inherent_data = sp_timestamp::InherentType::decode(&mut last_timestamp.as_slice())

            .expect("Timestamp data must be decoded; qed");

        let new_inherent_data: sp_timestamp::InherentType = max(

            last_inherent_data.add(slot_duration.as_millis()),

            sp_timestamp::InherentType::current(),

        );

        client

            .insert_aux(

                &[(TIMESTAMP_AUX_KEY, new_inherent_data.encode().as_slice())],

                &[],

            )

            .expect("Should be able to write to aux storage; qed");

        sp_timestamp::InherentDataProvider::new(new_inherent_data)

        let current_timestamp = sp_timestamp::InherentType::current();

        client

            .insert_aux(

                &[(TIMESTAMP_AUX_KEY, current_timestamp.encode().as_slice())],

                &[],

            )

            .expect("Should be able to write to aux storage; qed");

        sp_timestamp::InherentDataProvider::new(current_timestamp)

}

fn new_full<

    OverseerGenerator: OverseerGen,

    Network: sc_network::NetworkBackend<Block, <Block as BlockT>::Hash>,

>(

    sealing: Sealing,

    mut config: Configuration,

    NewFullParams {

        telemetry_worker_handle,

        ..

    }: NewFullParams<OverseerGenerator>,

) -> Result<NewFull, Error> {

    let role = config.role.clone();

    let basics = new_partial_basics(&mut config, telemetry_worker_handle)?;

    let prometheus_registry = config.prometheus_registry().cloned();

    let keystore = basics.keystore_container.local_keystore();

    let select_chain = SelectRelayChain::new_longest_chain(basics.backend.clone());

    let service::PartialComponents::<_, _, SelectRelayChain<_>, _, _, _> {

        client,

        backend,

        mut task_manager,

        keystore_container,

        select_chain,

        import_queue,

        transaction_pool,

        other: (block_import, babe_link, slot_duration, mut telemetry),

    } = new_partial::<SelectRelayChain<_>>(&mut config, basics, select_chain)?;

    let metrics = Network::register_notification_metrics(

        config.prometheus_config.as_ref().map(|cfg| &cfg.registry),

    );

    let net_config =

        sc_network::config::FullNetworkConfiguration::<_, _, Network>::new(&config.network);

    let (network, system_rpc_tx, tx_handler_controller, network_starter, sync_service) =

        service::build_network(service::BuildNetworkParams {

            config: &config,

            net_config,

            client: client.clone(),

            transaction_pool: transaction_pool.clone(),

            spawn_handle: task_manager.spawn_handle(),

            import_queue,

            block_announce_validator_builder: None,

            warp_sync_params: None,

            block_relay: None,

            metrics,

        })?;

    if config.offchain_worker.enabled {

        use futures::FutureExt;

        task_manager.spawn_handle().spawn(

            "offchain-workers-runner",

            "offchain-work",

            sc_offchain::OffchainWorkers::new(sc_offchain::OffchainWorkerOptions {

                runtime_api_provider: client.clone(),

                keystore: Some(keystore_container.keystore()),

                offchain_db: backend.offchain_storage(),

                transaction_pool: Some(OffchainTransactionPoolFactory::new(

                    transaction_pool.clone(),

                )),

                network_provider: Arc::new(network.clone()),

                is_validator: role.is_authority(),

                enable_http_requests: false,

                custom_extensions: move |_| vec![],

            })

            .run(client.clone(), task_manager.spawn_handle())

            .boxed(),

        );

    }

    let mut command_sink = None;

    if role.is_authority() {

        let proposer = sc_basic_authorship::ProposerFactory::new(

            task_manager.spawn_handle(),

            client.clone(),

            transaction_pool.clone(),

            prometheus_registry.as_ref(),

            telemetry.as_ref().map(|x| x.handle()),

        );

        let commands_stream: Box<

            dyn Stream<Item = EngineCommand<<Block as BlockT>::Hash>> + Send + Sync + Unpin,

        > = match sealing {

                let (sink, stream) = futures::channel::mpsc::channel(1000);

                // Keep a reference to the other end of the channel. It goes to the RPC.

                command_sink = Some(sink);

                Box::new(stream)

        let babe_config = babe_link.config();

        let babe_consensus_provider = BabeConsensusDataProvider::new(

            client.clone(),

            keystore,

            babe_link.epoch_changes().clone(),

            babe_config.authorities.clone(),

        )

        .map_err(|babe_error| {

        })?;

        let client_clone = client.clone();

        task_manager.spawn_essential_handle().spawn_blocking(

            "authorship_task",

            Some("block-authoring"),

            run_manual_seal(ManualSealParams {

                block_import,

                env: proposer,

                client: client.clone(),

                pool: transaction_pool.clone(),

                commands_stream,

                select_chain,

                create_inherent_data_providers: move |parent, ()| {

                    let client_clone = client_clone.clone();

                    async move {

                        let parachain =

                            EmptyParachainsInherentDataProvider::new(

                                client_clone.clone(),

                                parent,

                            );

                        let timestamp = get_next_timestamp(client_clone, slot_duration);

                        let slot =

                            sp_consensus_babe::inherents::InherentDataProvider::from_timestamp_and_slot_duration(

                                *timestamp,

                                slot_duration,

                            );

                        Ok((slot, timestamp, parachain))

                    }

                },

                consensus_data_provider: Some(Box::new(babe_consensus_provider)),

            }),

        );

    }

    let rpc_extensions_builder = {

        let client = client.clone();

        let transaction_pool = transaction_pool.clone();

        let chain_spec = config.chain_spec.cloned_box();

              -> Result<RpcExtension, service::Error> {

            let deps = DevDeps {

                client: client.clone(),

                pool: transaction_pool.clone(),

                chain_spec: chain_spec.cloned_box(),

                deny_unsafe,

                command_sink: command_sink.clone(),

            };

            create_dev_rpc_extension(deps).map_err(Into::into)

        }

    let rpc_handlers = service::spawn_tasks(service::SpawnTasksParams {

        config,

        backend: backend.clone(),

        client: client.clone(),

        keystore: keystore_container.keystore(),

        network: network.clone(),

        sync_service: sync_service.clone(),

        rpc_builder: Box::new(rpc_extensions_builder),

        transaction_pool: transaction_pool.clone(),

        task_manager: &mut task_manager,

        system_rpc_tx,

        tx_handler_controller,

        telemetry: telemetry.as_mut(),

    })?;

    network_starter.start_network();

    Ok(NewFull {

        task_manager,

        client,

        overseer_handle: None,

        network,

        sync_service,

        rpc_handlers,

        backend,

    })

}

fn new_partial<ChainSelection>(

    config: &mut Configuration,

    Basics {

        task_manager,

        backend,

        client,

        keystore_container,

        telemetry,

    }: Basics,

    select_chain: ChainSelection,

) -> Result<

    service::PartialComponents<

        FullClient,

        FullBackend,

        ChainSelection,

        sc_consensus::DefaultImportQueue<Block>,

        sc_transaction_pool::FullPool<Block, FullClient>,

        (

            BabeBlockImport<Block, FullClient, Arc<FullClient>>,

            BabeLink<Block>,

            SlotDuration,

            Option<Telemetry>,

        ),

    >,

    Error,

>

where

    ChainSelection: 'static + SelectChain<Block>,

{

    let transaction_pool = sc_transaction_pool::BasicPool::new_full(

        config.transaction_pool.clone(),

        config.role.is_authority().into(),

        config.prometheus_registry(),

        task_manager.spawn_essential_handle(),

        client.clone(),

    );

    let babe_config = babe::configuration(&*client)?;

    let (babe_block_import, babe_link) =

        babe::block_import(babe_config.clone(), client.clone(), client.clone())?;

    let slot_duration = babe_link.config().slot_duration();

    // Create manual seal block import with manual seal block import queue

    let import_queue = sc_consensus_manual_seal::import_queue(

        Box::new(babe_block_import.clone()),

        &task_manager.spawn_essential_handle(),

        config.prometheus_registry(),

    );

    Ok(service::PartialComponents {

        client,

        backend,

        task_manager,

        keystore_container,

        select_chain,

        import_queue,

        transaction_pool,

        other: (babe_block_import, babe_link, slot_duration, telemetry),

    })

}

fn new_partial_basics(

    config: &mut Configuration,

    telemetry_worker_handle: Option<TelemetryWorkerHandle>,

) -> Result<Basics, Error> {

    let telemetry = config

        .telemetry_endpoints

        .clone()

        .filter(|x| !x.is_empty())

        .map(move |endpoints| -> Result<_, telemetry::Error> {

        })

        .transpose()?;

    let heap_pages = config

        .default_heap_pages

        .map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |h| HeapAllocStrategy::Static {

        });

    let executor = WasmExecutor::builder()

        .with_execution_method(config.wasm_method)

        .with_onchain_heap_alloc_strategy(heap_pages)

        .with_offchain_heap_alloc_strategy(heap_pages)

        .with_max_runtime_instances(config.max_runtime_instances)

        .with_runtime_cache_size(config.runtime_cache_size)

        .build();

    let (client, backend, keystore_container, task_manager) =

        service::new_full_parts::<Block, RuntimeApi, _>(

            config,

            telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),

            executor,

        )?;

    let client = Arc::new(client);

    let telemetry = telemetry.map(|(worker, telemetry)| {

    });

    Ok(Basics {

        task_manager,

        client,

        backend,

        keystore_container,

        telemetry,

    })

}