fn build_manual_seal_import_queue(

    _client: Arc<ParachainClient>,

    block_import: DevParachainBlockImport,

    config: &Configuration,

    _telemetry: Option<TelemetryHandle>,

    task_manager: &TaskManager,

) -> Result<sc_consensus::DefaultImportQueue<Block>, sc_service::Error> {

    Ok(sc_consensus_manual_seal::import_queue(

        Box::new(block_import),

        &task_manager.spawn_essential_handle(),

        config.prometheus_registry(),

    ))

}

            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 mut para_ids: Vec<ParaId> = client

                    .runtime_api()

                    .registered_paras(block)

                    .expect("registered_paras runtime API should exist")

                    .into_iter()

                    .collect();

                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 = HeadData(para_header).encode();

                let para_head_key = RelayWellKnownKeys::para_head(para_id);

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

                let slot_duration = sc_consensus_aura::standalone::slot_duration_at(

                    &*client.clone(),

                    block,

                ).expect("Slot duration should be set");

                MockTimestampInherentDataProvider::advance_timestamp(

                    slot_duration.as_millis(),

                let timestamp = MockTimestampInherentDataProvider::load();

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

                    timestamp.into(),

                    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();

                let randomness_enabler_messages: Vec<(bool, Option<[u8; 32]>)> = mock_randomness_receiver.drain().collect();

                if let Some((enable_randomness, new_seed)) = randomness_enabler_messages.last() {

                    let value = client

                        .get_aux(RANDOMNESS_ACTIVATED_AUX_KEY)

                        .expect("Should be able to query aux storage; qed").unwrap_or((false, Option::<[u8; 32]>::None).encode());

                    let (_mock_additional_randomness, mut mock_randomness_seed): (bool, Option<[u8; 32]>) = Decode::decode(&mut value.as_slice()).expect("Boolean non-decodable");

                    if let Some(new_seed) = new_seed {

                        mock_randomness_seed = Some(*new_seed);

                    }

                    client

                    .insert_aux(

                        &[(RANDOMNESS_ACTIVATED_AUX_KEY, (enable_randomness, mock_randomness_seed).encode().as_slice())],

                        &[],

                    )

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

                }

                let value = client

                    .get_aux(RANDOMNESS_ACTIVATED_AUX_KEY)

                    .expect("Should be able to query aux storage; qed").unwrap_or((false, Option::<[u8; 32]>::None).encode());

                let (mock_additional_randomness, mock_randomness_seed): (bool, Option<[u8; 32]>) = Decode::decode(&mut value.as_slice()).expect("Boolean non-decodable");

                let container_chains_exclusion_messages: Vec<Vec<ParaId>> = mock_container_chains_exclusion_receiver.drain().collect();

                if let Some(mock_excluded_container_chains) = container_chains_exclusion_messages.last() {

                    client

                        .insert_aux(

                            &[(CONTAINER_CHAINS_EXCLUSION_AUX_KEY, mock_excluded_container_chains.encode().as_slice())],

                            &[],

                        )

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

                }

                let new_excluded_container_chains_value = client

                    .get_aux(CONTAINER_CHAINS_EXCLUSION_AUX_KEY)

                    .expect("Should be able to query aux storage; qed").unwrap_or(Vec::<ParaId>::new().encode());

                let mock_excluded_container_chains: Vec<ParaId> = Decode::decode(&mut new_excluded_container_chains_value.as_slice()).expect("Vector non-decodable");

                para_ids.retain(|x| !mock_excluded_container_chains.contains(x));

                let client_set_aside_for_cidp = client.clone();

                let client_for_xcm = client.clone();

                async move {

                    let mocked_author_noting =

                        tp_author_noting_inherent::MockAuthorNotingInherentDataProvider {

                            current_para_block,

                            relay_offset: 1000,

                            relay_blocks_per_para_block: 2,

                            para_ids,

                            slots_per_para_block: 1,

                        };

                    let mut additional_keys = mocked_author_noting.get_key_values();

                    let (registrar_paras_key_2002, para_info_2002) = mocked_relay_keys::get_mocked_registrar_paras(2002.into());

                    additional_keys.extend([(para_head_key, para_head_data), (relay_slot_key, Slot::from(relay_slot).encode()), (registrar_paras_key_2002, para_info_2002)]);

                    if mock_additional_randomness {

                        let mut mock_randomness: [u8; 32] = [0u8; 32];

                        mock_randomness[..4].copy_from_slice(&current_para_block.to_be_bytes());

                        if let Some(seed) = mock_randomness_seed {

                            for i in 0..32 {

                                mock_randomness[i] ^= seed[i];

                            }

                        }

                        additional_keys.extend([(RelayWellKnownKeys::CURRENT_BLOCK_RANDOMNESS.to_vec(), Some(mock_randomness).encode())]);

                        log::info!("mokcing randomnessss!!! {}", current_para_block);

                    }

                    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 time = MockTimestampInherentDataProvider;

                    let mocked_parachain = MockValidationDataInherentDataProvider {

                        current_para_block,

                        current_para_block_head: None,

                        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(|| {

                            log::info!(

                                "Detected pending validation code, sending go-ahead signal."

                            UpgradeGoAhead::GoAhead

                        }),

                    Ok((time, mocked_parachain, mocked_author_noting))

                }

            },

        Box::new(move |_| {

            let deps = tc_service_orchestrator_chain::parachain::rpc::FullDeps {

                client: client.clone(),

                pool: transaction_pool.clone(),

                command_sink: command_sink.clone(),

                xcm_senders: xcm_senders.clone(),

                randomness_sender: randomness_sender.clone(),

                container_chain_exclusion_sender: container_chains_exclusion_sender.clone(),

            };

            tc_service_orchestrator_chain::parachain::rpc::create_full(deps).map_err(Into::into)

        })

    fn is_dev(&self) -> bool {

        self.chain_type() == sc_chain_spec::ChainType::Development

    }