pub fn frontier_database_dir(config: &Configuration, path: &str) -> std::path::PathBuf {

    let config_dir = config

        .base_path

        .config_dir(config.chain_spec.id())

        .join("frontier")

        .join(path);

    config_dir

}

pub fn open_frontier_backend<C>(

    client: Arc<C>,

    config: &Configuration,

) -> Result<fc_db::kv::Backend<Block, C>, String>

where

    C: sp_blockchain::HeaderBackend<Block>,

{

    fc_db::kv::Backend::<Block, _>::new(

        client,

        &fc_db::kv::DatabaseSettings {

            source: match config.database {

                DatabaseSource::RocksDb { .. } => DatabaseSource::RocksDb {

                    path: frontier_database_dir(config, "db"),

                    cache_size: 0,

                },

}

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

        TIMESTAMP.with(|x| {

            *x.borrow_mut() += container_chain_template_frontier_runtime::SLOT_DURATION;

            inherent_data.put_data(sp_timestamp::INHERENT_IDENTIFIER, &*x.borrow())

        })

    }

pub fn import_queue(

    parachain_config: &Configuration,

    node_builder: &NodeBuilder<NodeConfig>,

) -> (ParachainBlockImport, BasicQueue<Block>) {

    let frontier_block_import =

        FrontierBlockImport::new(node_builder.client.clone(), node_builder.client.clone());

    // The parachain block import and import queue

    let block_import = cumulus_client_consensus_common::ParachainBlockImport::new(

        frontier_block_import,

        node_builder.backend.clone(),

    );

    let import_queue = nimbus_consensus::import_queue(

        node_builder.client.clone(),

        block_import.clone(),

        move |_, _| async move {

        },

        &node_builder.task_manager.spawn_essential_handle(),

        parachain_config.prometheus_registry(),

        false,

    )

    .expect("function never fails");

    (block_import, import_queue)

}

fn get_aura_id_from_seed(seed: &str) -> NimbusId {

    sp_core::sr25519::Pair::from_string(&format!("//{}", seed), None)

        .expect("static values are valid; qed")

        .public()

        .into()

}

pub async fn start_dev_node(

    parachain_config: Configuration,

    sealing: Sealing,

    rpc_config: crate::cli::RpcConfig,

    para_id: ParaId,

    hwbench: Option<sc_sysinfo::HwBench>,

) -> Result<TaskManager, sc_service::error::Error> {

    let node_builder = NodeConfig::new_builder(&parachain_config, hwbench)?;

    let filter_pool: Option<FilterPool> = Some(Arc::new(Mutex::new(BTreeMap::new())));

    let fee_history_cache: FeeHistoryCache = Arc::new(Mutex::new(BTreeMap::new()));

    let frontier_backend = fc_db::Backend::KeyValue(

        open_frontier_backend(node_builder.client.clone(), &parachain_config)?.into(),

    );

    let overrides = Arc::new(StorageOverrideHandler::new(node_builder.client.clone()));

    let fee_history_limit = rpc_config.fee_history_limit;

    let pubsub_notification_sinks: fc_mapping_sync::EthereumBlockNotificationSinks<

        fc_mapping_sync::EthereumBlockNotification<Block>,

    > = Default::default();

    let pubsub_notification_sinks = Arc::new(pubsub_notification_sinks);

    let (parachain_block_import, import_queue) = import_queue(&parachain_config, &node_builder);

    let mut node_builder = node_builder

        .build_substrate_network::<sc_network::NetworkWorker<_, _>>(

            &parachain_config,

            import_queue,

        )?;

    let mut command_sink = None;

    let mut xcm_senders = None;

    if parachain_config.role.is_authority() {

        let client = node_builder.client.clone();

        let (downward_xcm_sender, downward_xcm_receiver) = flume::bounded::<Vec<u8>>(100);

        let (hrmp_xcm_sender, hrmp_xcm_receiver) = flume::bounded::<(ParaId, Vec<u8>)>(100);

        xcm_senders = Some((downward_xcm_sender, hrmp_xcm_sender));

        let authorities = vec![get_aura_id_from_seed("alice")];

        command_sink = node_builder.install_manual_seal(ManualSealConfiguration {

            block_import: parachain_block_import,

            sealing,

            soft_deadline: None,

            select_chain: sc_consensus::LongestChain::new(node_builder.backend.clone()),

            consensus_data_provider: Some(Box::new(

                tc_consensus::ContainerManualSealAuraConsensusDataProvider::new(

                    SlotDuration::from_millis(

                        container_chain_template_frontier_runtime::SLOT_DURATION,

                    ),

                    authorities.clone(),

                ),

            )),

            create_inherent_data_providers: move |block: H256, ()| {

                let current_para_block = client

                    .number(block)

                    .expect("Header lookup should succeed")

                    .expect("Header passed in as parent should be present in backend.");

                let hash = client

                    .hash(current_para_block.saturating_sub(1))

                    .expect("Hash of the desired block must be present")

                    .expect("Hash of the desired block should exist");

                let para_header = client

                    .expect_header(hash)

                    .expect("Expected parachain header should exist")

                    .encode();

                let para_head_data: Vec<u8> = HeadData(para_header).encode();

                let client_set_aside_for_cidp = client.clone();

                let client_for_xcm = client.clone();

                let authorities_for_cidp = authorities.clone();

                let para_head_key = RelayWellKnownKeys::para_head(para_id);

                let relay_slot_key = RelayWellKnownKeys::CURRENT_SLOT.to_vec();

                let slot_duration = container_chain_template_frontier_runtime::SLOT_DURATION;

                let mut timestamp = 0u64;

                TIMESTAMP.with(|x| {

                    timestamp = x.clone().take();

                });

                timestamp += slot_duration;

                let relay_slot = sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(

						timestamp.into(),

						SlotDuration::from_millis(slot_duration),

                    );

                let relay_slot = u64::from(*relay_slot);

                let downward_xcm_receiver = downward_xcm_receiver.clone();

                let hrmp_xcm_receiver = hrmp_xcm_receiver.clone();

                async move {

                    let mocked_authorities_noting =

                        ccp_authorities_noting_inherent::MockAuthoritiesNotingInherentDataProvider {

                            current_para_block,

                            relay_offset: 1000,

                            relay_blocks_per_para_block: 2,

                            orchestrator_para_id: crate::chain_spec::ORCHESTRATOR,

                            container_para_id: para_id,

                            authorities: authorities_for_cidp

                    };

                    let mut additional_keys = mocked_authorities_noting.get_key_values();

                    additional_keys.append(&mut vec![(para_head_key, para_head_data), (relay_slot_key, Slot::from(relay_slot).encode())]);

                    let time = MockTimestampInherentDataProvider;

                    let current_para_head = client_set_aside_for_cidp

                            .header(block)

                            .expect("Header lookup should succeed")

                            .expect("Header passed in as parent should be present in backend.");

                    let should_send_go_ahead = match client_set_aside_for_cidp

                            .runtime_api()

                            .collect_collation_info(block, &current_para_head)

                            Ok(info) => info.new_validation_code.is_some(),

                    let mocked_parachain = MockValidationDataInherentDataProvider {

                        current_para_block,

                        current_para_block_head: None,

                        relay_offset: 1000,

                        relay_blocks_per_para_block: 2,

                        // TODO: Recheck

                        para_blocks_per_relay_epoch: 10,

                        relay_randomness_config: (),

                        xcm_config: MockXcmConfig::new(

                            &*client_for_xcm,

                            block,

                            Default::default(),

                        ),

                        raw_downward_messages: downward_xcm_receiver.drain().collect(),

                        raw_horizontal_messages: hrmp_xcm_receiver.drain().collect(),

                        additional_key_values: Some(additional_keys),

                        para_id,

                        upgrade_go_ahead: should_send_go_ahead.then(|| {

                        }),

                    };

                    Ok((time, mocked_parachain, mocked_authorities_noting))

                }

            },

        })?;

    let frontier_backend = Arc::new(frontier_backend);

    crate::rpc::spawn_essential_tasks(crate::rpc::SpawnTasksParams {

        task_manager: &node_builder.task_manager,

        client: node_builder.client.clone(),

        substrate_backend: node_builder.backend.clone(),

        frontier_backend: frontier_backend.clone(),

        filter_pool: filter_pool.clone(),

        overrides: overrides.clone(),

        fee_history_limit,

        fee_history_cache: fee_history_cache.clone(),

        sync_service: node_builder.network.sync_service.clone(),

        pubsub_notification_sinks: pubsub_notification_sinks.clone(),

    });

    let block_data_cache = Arc::new(fc_rpc::EthBlockDataCacheTask::new(

        node_builder.task_manager.spawn_handle(),

        overrides.clone(),

        rpc_config.eth_log_block_cache,

        rpc_config.eth_statuses_cache,

        node_builder.prometheus_registry.clone(),

    ));

    let rpc_builder = {

        let client = node_builder.client.clone();

        let pool = node_builder.transaction_pool.clone();

        let pubsub_notification_sinks = pubsub_notification_sinks;

        let network = node_builder.network.network.clone();

        let sync = node_builder.network.sync_service.clone();

        let filter_pool = filter_pool;

        let frontier_backend = frontier_backend.clone();

        let backend = node_builder.backend.clone();

        let max_past_logs = rpc_config.max_past_logs;

        let overrides = overrides;

        let block_data_cache = block_data_cache;

        Box::new(move |subscription_task_executor| {

            let graph_pool= pool.0.as_any()

                .downcast_ref::<sc_transaction_pool::BasicPool<

                    sc_transaction_pool::FullChainApi<ParachainClient, Block>

                    , Block

                >>().expect("Frontier container chain template supports only single state transaction pool! Use --pool-type=single-state");

            let deps = crate::rpc::FullDeps {

                backend: backend.clone(),

                client: client.clone(),

                filter_pool: filter_pool.clone(),

                frontier_backend: match &*frontier_backend {

                    fc_db::Backend::KeyValue(b) => b.clone(),

                graph: graph_pool.pool().clone(),

                pool: pool.clone(),

                max_past_logs,

                fee_history_limit,

                fee_history_cache: fee_history_cache.clone(),

                network: network.clone(),

                sync: sync.clone(),

                block_data_cache: block_data_cache.clone(),

                overrides: overrides.clone(),

                is_authority: false,

                command_sink: command_sink.clone(),

                xcm_senders: xcm_senders.clone(),

            };

            crate::rpc::create_full(

                deps,

                subscription_task_executor,

                pubsub_notification_sinks.clone(),

            )

            .map_err(Into::into)

        })

    let node_builder = node_builder.spawn_common_tasks(parachain_config, rpc_builder)?;

    log::info!("Development Service Ready");

    node_builder.network.start_network.start_network();

    Ok(node_builder.task_manager)

}