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

        None

    }

pub fn build_check_assigned_para_id(

    client: Arc<dyn OrchestratorChainInterface>,

    sync_keystore: KeystorePtr,

    cc_spawn_tx: UnboundedSender<CcSpawnMsg>,

    spawner: impl SpawnEssentialNamed,

) {

    let check_assigned_para_id_task = async move {

        let mut import_notifications = client.finality_notification_stream().await.unwrap();

        while let Some(msg) = import_notifications.next().await {

            let block_hash = msg.hash();

            let client_set_aside_for_cidp = client.clone();

            let sync_keystore = sync_keystore.clone();

            let cc_spawn_tx = cc_spawn_tx.clone();

            check_assigned_para_id(

                cc_spawn_tx,

                sync_keystore,

                client_set_aside_for_cidp,

                block_hash,

            )

            .await

            .unwrap();

    };

    spawner.spawn_essential(

        "check-assigned-para-id",

        None,

        Box::pin(check_assigned_para_id_task),

    );

}

async fn check_assigned_para_id(

    cc_spawn_tx: UnboundedSender<CcSpawnMsg>,

    sync_keystore: KeystorePtr,

    client_set_aside_for_cidp: Arc<dyn OrchestratorChainInterface>,

    block_hash: H256,

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

    let current_container_chain_para_id =

        tc_consensus::first_eligible_key::<dyn OrchestratorChainInterface, NimbusPair>(

            client_set_aside_for_cidp.as_ref(),

            &block_hash,

            sync_keystore.clone(),

        )

        .await

        .map(|(_nimbus_key, para_id)| para_id);

    let next_container_chain_para_id = tc_consensus::first_eligible_key_next_session::<

        dyn OrchestratorChainInterface,

        NimbusPair,

    >(

        client_set_aside_for_cidp.as_ref(),

        &block_hash,

        sync_keystore,

    )

    .await

    .map(|(_nimbus_key, para_id)| para_id);

    cc_spawn_tx.send(CcSpawnMsg::UpdateAssignment {

        current: current_container_chain_para_id,

        next: next_container_chain_para_id,

    })?;

    Ok(())

}

pub fn import_queue(

    parachain_config: &Configuration,

    node_builder: &NodeBuilder<NodeConfig>,

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

    // The nimbus import queue ONLY checks the signature correctness

    // Any other checks corresponding to the author-correctness should be done

    // in the runtime

    let block_import =

        ParachainBlockImport::new(node_builder.client.clone(), node_builder.backend.clone());

    let import_queue = nimbus_consensus::import_queue(

        node_builder.client.clone(),

        block_import.clone(),

        move |_, _| async move {

            let time = sp_timestamp::InherentDataProvider::from_system_time();

            Ok((time,))

        },

        &node_builder.task_manager.spawn_essential_handle(),

        parachain_config.prometheus_registry(),

        false,

        false,

    )

    .expect("function never fails");

    (block_import, import_queue)

}

async fn start_node_impl(

    orchestrator_config: Configuration,

    polkadot_config: Configuration,

    container_chain_config: Option<(ContainerChainCli, tokio::runtime::Handle)>,

    collator_options: CollatorOptions,

    para_id: ParaId,

    hwbench: Option<sc_sysinfo::HwBench>,

    max_pov_percentage: Option<u32>,

) -> sc_service::error::Result<(TaskManager, Arc<ParachainClient>)> {

    let parachain_config = prepare_node_config(orchestrator_config);

    let chain_type: sc_chain_spec::ChainType = parachain_config.chain_spec.chain_type();

    let relay_chain = crate::chain_spec::Extensions::try_get(&*parachain_config.chain_spec)

        .map(|e| e.relay_chain.clone())

        .ok_or("Could not find relay_chain extension in chain-spec.")?;

    let (cc_spawn_tx, cc_spawn_rx) = unbounded_channel();

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

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

    let (relay_chain_interface, collator_key) = node_builder

        .build_relay_chain_interface(&parachain_config, polkadot_config, collator_options.clone())

        .await?;

    let validator = parachain_config.role.is_authority();

    let force_authoring = parachain_config.force_authoring;

    let node_builder = node_builder

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

            &parachain_config,

            para_id,

            import_queue,

            relay_chain_interface.clone(),

        )

        .await?;

    let rpc_builder = {

        let client = node_builder.client.clone();

        let transaction_pool = node_builder.transaction_pool.clone();

        Box::new(move |_| {

            let deps = crate::rpc::FullDeps {

                client: client.clone(),

                pool: transaction_pool.clone(),

                command_sink: None,

                xcm_senders: None,

                randomness_sender: None,

                container_chain_exclusion_sender: None,

            };

            crate::rpc::create_full(deps).map_err(Into::into)

        })

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

    let relay_chain_slot_duration = Duration::from_secs(6);

    let overseer_handle = relay_chain_interface

        .overseer_handle()

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

    let sync_keystore = node_builder.keystore_container.keystore();

    let mut collate_on_tanssi: Arc<

        dyn Fn() -> (CancellationToken, futures::channel::oneshot::Receiver<()>) + Send + Sync,

    > = Arc::new(move || {

        if validator {

            panic!("Called uninitialized collate_on_tanssi");

            panic!("Called collate_on_tanssi when node is not running as a validator");

    });

    let announce_block = {

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

        Arc::new(move |hash, data| sync_service.announce_block(hash, data))

    };

    let (mut node_builder, import_queue_service) = node_builder.extract_import_queue_service();

    start_relay_chain_tasks(StartRelayChainTasksParams {

        client: node_builder.client.clone(),

        announce_block: announce_block.clone(),

        para_id,

        relay_chain_interface: relay_chain_interface.clone(),

        task_manager: &mut node_builder.task_manager,

        da_recovery_profile: if validator {

            DARecoveryProfile::Collator

            DARecoveryProfile::FullNode

        import_queue: import_queue_service,

        relay_chain_slot_duration,

        recovery_handle: Box::new(overseer_handle.clone()),

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

    })?;

    let orchestrator_chain_interface_builder = OrchestratorChainInProcessInterfaceBuilder {

        client: node_builder.client.clone(),

        backend: node_builder.backend.clone(),

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

        overseer_handle: overseer_handle.clone(),

    };

    let orchestrator_chain_interface = orchestrator_chain_interface_builder.build();

    if validator {

        let collator_key = collator_key

            .clone()

            .expect("Command line arguments do not allow this. qed");

        // Start task which detects para id assignment, and starts/stops container chains.

        // Note that if this node was started without a `container_chain_config`, we don't

        // support collation on container chains, so there is no need to detect changes to assignment

        if container_chain_config.is_some() {

            build_check_assigned_para_id(

                orchestrator_chain_interface.clone(),

                sync_keystore.clone(),

                cc_spawn_tx.clone(),

                node_builder.task_manager.spawn_essential_handle(),

            );

        }

        let start_collation = {

            // Params for collate_on_tanssi closure

            let node_spawn_handle = node_builder.task_manager.spawn_handle().clone();

            let node_keystore = node_builder.keystore_container.keystore().clone();

            let node_telemetry_handle = node_builder.telemetry.as_ref().map(|t| t.handle()).clone();

            let node_client = node_builder.client.clone();

            let node_backend = node_builder.backend.clone();

            let relay_interface = relay_chain_interface.clone();

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

            let orchestrator_tx_pool = node_builder.transaction_pool.clone();

            let overseer = overseer_handle.clone();

            let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording(

                node_spawn_handle.clone(),

                node_client.clone(),

                node_builder.transaction_pool.clone(),

                node_builder.prometheus_registry.as_ref(),

                node_telemetry_handle.clone(),

            );

            move || {

                start_consensus_orchestrator(

                    node_client.clone(),

                    node_backend.clone(),

                    block_import.clone(),

                    node_spawn_handle.clone(),

                    relay_interface.clone(),

                    node_sync_service.clone(),

                    node_keystore.clone(),

                    force_authoring,

                    relay_chain_slot_duration,

                    para_id,

                    collator_key.clone(),

                    overseer.clone(),

                    announce_block.clone(),

                    proposer_factory.clone(),

                    orchestrator_tx_pool.clone(),

                    max_pov_percentage,

                )

            }

        };

        // Save callback for later, used when collator rotates from container chain back to orchestrator chain

        collate_on_tanssi = Arc::new(start_collation);

    }

    let sync_keystore = node_builder.keystore_container.keystore();

    if let Some((container_chain_cli, tokio_handle)) = container_chain_config {

        if !validator {

            if let Some(container_chain_para_id) = container_chain_cli.base.para_id {

                cc_spawn_tx

                    .send(CcSpawnMsg::UpdateAssignment {

                        current: Some(container_chain_para_id.into()),

                        next: Some(container_chain_para_id.into()),

                    })

                    .map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?;

            }

        }

        let orchestrator_client = node_builder.client.clone();

        let orchestrator_tx_pool = node_builder.transaction_pool.clone();

        let spawn_handle = node_builder.task_manager.spawn_handle();

        let container_chain_spawner = ContainerChainSpawner {

                orchestrator_chain_interface,

                container_chain_cli,

                tokio_handle,

                chain_type,

                relay_chain,

                relay_chain_interface,

                sync_keystore,

                orchestrator_para_id: para_id,

                data_preserver: false,

                collation_params: if validator {

                    Some(spawner::CollationParams {

                        orchestrator_client: Some(orchestrator_client.clone()),

                        orchestrator_tx_pool: Some(orchestrator_tx_pool),

                        orchestrator_para_id: para_id,

                        collator_key: collator_key

                            .expect("there should be a collator key if we're a validator"),

                        solochain: false,

                    })

                    None

                spawn_handle,

                generate_rpc_builder: tc_service_container_chain::rpc::GenerateSubstrateRpcBuilder::<

                    dancebox_runtime::RuntimeApi,

                >::new(),

                phantom: PhantomData,

            },

            state: Default::default(),

            db_folder_cleanup_done: false,

            collate_on_tanssi,

            collation_cancellation_constructs: None,

        };

        let state = container_chain_spawner.state.clone();

        node_builder.task_manager.spawn_essential_handle().spawn(

            "container-chain-spawner-rx-loop",

            None,

            container_chain_spawner.rx_loop(cc_spawn_rx, validator, false),

        );

        node_builder.task_manager.spawn_essential_handle().spawn(

            "container-chain-spawner-debug-state",

            None,

            monitor::monitor_task(state),

        )

    }

    Ok((node_builder.task_manager, node_builder.client))

}

fn start_consensus_orchestrator(

    client: Arc<ParachainClient>,

    backend: Arc<FullBackend>,

    block_import: ParachainBlockImport,

    spawner: SpawnTaskHandle,

    relay_chain_interface: Arc<dyn RelayChainInterface>,

    sync_oracle: Arc<SyncingService<Block>>,

    keystore: KeystorePtr,

    force_authoring: bool,

    relay_chain_slot_duration: Duration,

    para_id: ParaId,

    collator_key: CollatorPair,

    overseer_handle: OverseerHandle,

    announce_block: Arc<dyn Fn(Hash, Option<Vec<u8>>) + Send + Sync>,

    proposer_factory: ParachainProposerFactory,

    orchestrator_tx_pool: Arc<TransactionPoolHandle<Block, ParachainClient>>,

    max_pov_percentage: Option<u32>,

) -> (CancellationToken, futures::channel::oneshot::Receiver<()>) {

    let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)

        .expect("start_consensus_orchestrator: slot duration should exist");

    let proposer = Proposer::new(proposer_factory);

    let collator_service = CollatorService::new(

        client.clone(),

        Arc::new(spawner.clone()),

        announce_block,

        client.clone(),

    );

    let relay_chain_interace_for_cidp = relay_chain_interface.clone();

    let client_set_aside_for_cidp = client.clone();

    let client_set_aside_for_orch = client.clone();

    let client_for_hash_provider = client.clone();

    let client_for_slot_duration_provider = client.clone();

    let code_hash_provider = move |block_hash| {

        client_for_hash_provider

            .code_at(block_hash)

            .ok()

            .map(polkadot_primitives::ValidationCode)

            .map(|c| c.hash())

    };

    let cancellation_token = CancellationToken::new();

    let buy_core_params = BuyCoreParams::Orchestrator {

        orchestrator_tx_pool,

        orchestrator_client: client.clone(),

    };

    let params = LookaheadTanssiAuraParams {

        max_pov_percentage,

        get_current_slot_duration: move |block_hash| {

            sc_consensus_aura::standalone::slot_duration_at(

                &*client_for_slot_duration_provider,

                block_hash,

            )

            .expect("Slot duration should be set")

        },

        create_inherent_data_providers: move |block_hash, (relay_parent, _validation_data)| {

            let relay_chain_interface = relay_chain_interace_for_cidp.clone();

            let client_set_aside_for_cidp = client_set_aside_for_cidp.clone();

            async move {

                let para_ids = match client_set_aside_for_cidp

                    .runtime_api()

                    .api_version::<dyn CollatorAssignmentApi<Block, AccountId, ParaId>>(

                    block_hash,

                )? {

                    Some(version) if version >= 2 => client_set_aside_for_cidp

                        .runtime_api()

                        .parachains_with_some_collators(block_hash)?,

                    _ => client_set_aside_for_cidp

                        .runtime_api()

                        .registered_paras(block_hash)?,

                let para_ids: Vec<_> = para_ids.into_iter().collect();

                let author_noting_inherent =

                    tp_author_noting_inherent::OwnParachainInherentData::create_at(

                        relay_parent,

                        &relay_chain_interface,

                        &para_ids,

                    )

                    .await;

                let slot_duration = sc_consensus_aura::standalone::slot_duration_at(

                    &*client_set_aside_for_cidp.clone(),

                    block_hash,

                )

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

                let timestamp = sp_timestamp::InherentDataProvider::from_system_time();

                let slot =

						sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(

							*timestamp,

							slot_duration,

						);

                let author_noting_inherent = author_noting_inherent.ok_or_else(|| {

                    Box::<dyn std::error::Error + Send + Sync>::from(

                        "Failed to create author noting inherent",

                    )

                })?;

                Ok((slot, timestamp, author_noting_inherent))

            }

        },

        get_orchestrator_aux_data: move |block_hash: H256, (_relay_parent, _validation_data)| {

            let client_set_aside_for_orch = client_set_aside_for_orch.clone();

            async move {

                let authorities = tc_consensus::authorities::<Block, ParachainClient, NimbusPair>(

                    client_set_aside_for_orch.as_ref(),

                    &block_hash,

                    para_id,

                );

                let authorities = authorities.ok_or_else(|| {

                    Box::<dyn std::error::Error + Send + Sync>::from(

                        "Failed to fetch authorities with error",

                    )

                })?;

                log::info!(

                    "Authorities {:?} found for header {:?}",

                let aux_data = OrchestratorAuraWorkerAuxData {

                    authorities,

                    // This is the orchestrator consensus, it does not have a slot frequency

                    slot_freq: None,

                };

                Ok(aux_data)

            }

        },

        block_import,

        para_client: client,

        relay_client: relay_chain_interface,

        sync_oracle,

        keystore,

        collator_key,

        para_id,

        overseer_handle,

        orchestrator_slot_duration: slot_duration,

        relay_chain_slot_duration,

        force_authoring,

        proposer,

        collator_service,

        authoring_duration: Duration::from_millis(2000),

        code_hash_provider,

        para_backend: backend,

        cancellation_token: cancellation_token.clone(),

        buy_core_params,

    };

    let (fut, exit_notification_receiver) =

        lookahead_tanssi_aura::run::<_, Block, NimbusPair, _, _, _, _, _, _, _, _, _, _, _, _, _>(

            params,

        );

    spawner.spawn("tanssi-aura", None, fut);

    (cancellation_token, exit_notification_receiver)

}

pub async fn start_parachain_node(

    parachain_config: Configuration,

    polkadot_config: Configuration,

    container_config: Option<(ContainerChainCli, tokio::runtime::Handle)>,

    collator_options: CollatorOptions,

    para_id: ParaId,

    hwbench: Option<sc_sysinfo::HwBench>,

    max_pov_percentage: Option<u32>,

) -> sc_service::error::Result<(TaskManager, Arc<ParachainClient>)> {

    start_node_impl(

        parachain_config,

        polkadot_config,

        container_config,

        collator_options,

        para_id,

        hwbench,

        max_pov_percentage,

    )

    .instrument(sc_tracing::tracing::info_span!(

        sc_tracing::logging::PREFIX_LOG_SPAN,

        name = "Orchestrator",

    ))

    .await

}

pub async fn start_solochain_node(

    polkadot_config: Configuration,

    container_chain_cli: ContainerChainCli,

    collator_options: CollatorOptions,

    hwbench: Option<sc_sysinfo::HwBench>,

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

    let tokio_handle = polkadot_config.tokio_handle.clone();

    let orchestrator_para_id = Default::default();

    let chain_type = polkadot_config.chain_spec.chain_type().clone();

    let relay_chain = polkadot_config.chain_spec.id().to_string();

    // We use the relaychain keystore config for collators

    // Ensure that the user did not provide any custom keystore path for collators

    if container_chain_cli

        .base

        .base

        .keystore_params

        .keystore_path

        .is_some()

        panic!(

            "--keystore-path not allowed here, must be set in relaychain args, after the first --"

        )

    }

    let keystore = &polkadot_config.keystore;

    // Instead of putting keystore in

    // Collator1000-01/data/chains/simple_container_2000/keystore

    // We put it in

    // Collator1000-01/relay-data/chains/dancelight_local_testnet/keystore

    // And same for "network" folder

    // But zombienet will put the keys in the old path, so we need to manually copy it if we

    // are running under zombienet

    copy_zombienet_keystore(keystore, container_chain_cli.base_path())?;

    let keystore_container = KeystoreContainer::new(keystore)?;

    let prometheus_registry = None;

    let mut task_manager = TaskManager::new(tokio_handle.clone(), prometheus_registry)?;

    let telemetry_worker_handle = None;

    // Dummy parachain config only needed because `build_relay_chain_interface` needs to know if we

    // are collators or not

    let validator = container_chain_cli.base.collator;

    let mut dummy_parachain_config = dummy_config(

        polkadot_config.tokio_handle.clone(),

        polkadot_config.base_path.clone(),

    );

    dummy_parachain_config.role = if validator {

        Role::Authority

        Role::Full

    let (relay_chain_interface, collator_key) =

        cumulus_client_service::build_relay_chain_interface(

            polkadot_config,

            &dummy_parachain_config,

            telemetry_worker_handle.clone(),

            &mut task_manager,

            collator_options.clone(),

            hwbench.clone(),

        )

        .await

        .map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?;

    log::info!("start_solochain_node: is validator? {}", validator);

    let overseer_handle = relay_chain_interface

        .overseer_handle()

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

    let sync_keystore = keystore_container.keystore();

    let collate_on_tanssi: Arc<

        dyn Fn() -> (CancellationToken, futures::channel::oneshot::Receiver<()>) + Send + Sync,

    > = Arc::new(move || {

        // collate_on_tanssi will not be called in solochains because solochains use a different consensus

        // mechanism and need validators instead of collators.

        // The runtime enforces this because the orchestrator_chain is never assigned any collators.

        panic!("Called collate_on_tanssi on solochain collator. This is unsupported and the runtime shouldn't allow this, it is a bug")

    });

    let orchestrator_chain_interface_builder = OrchestratorChainSolochainInterfaceBuilder {

        overseer_handle: overseer_handle.clone(),

        relay_chain_interface: relay_chain_interface.clone(),

    };

    let orchestrator_chain_interface = orchestrator_chain_interface_builder.build();

    // Channel to send messages to start/stop container chains

    let (cc_spawn_tx, cc_spawn_rx) = unbounded_channel();

    if validator {

        // Start task which detects para id assignment, and starts/stops container chains.

        build_check_assigned_para_id(

            orchestrator_chain_interface.clone(),

            sync_keystore.clone(),

            cc_spawn_tx.clone(),

            task_manager.spawn_essential_handle(),

        );

    }

    if !validator {

        if let Some(container_chain_para_id) = container_chain_cli.base.para_id {

            cc_spawn_tx

                .send(CcSpawnMsg::UpdateAssignment {

                    current: Some(container_chain_para_id.into()),

                    next: Some(container_chain_para_id.into()),

                })

                .map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?;

        }

    }

    let spawn_handle = task_manager.spawn_handle();

    let container_chain_spawner = ContainerChainSpawner {

            orchestrator_chain_interface,

            container_chain_cli,

            tokio_handle,

            chain_type,

            relay_chain,

            relay_chain_interface,

            sync_keystore,

            orchestrator_para_id,

            collation_params: if validator {

                Some(spawner::CollationParams {

                    // TODO: all these args must be solochain instead of orchestrator

                    orchestrator_client: None,

                    orchestrator_tx_pool: None,

                    orchestrator_para_id,

                    collator_key: collator_key

                        .expect("there should be a collator key if we're a validator"),

                    solochain: true,

                })

                None

            spawn_handle,

            data_preserver: false,

            generate_rpc_builder: tc_service_container_chain::rpc::GenerateSubstrateRpcBuilder::<

                dancebox_runtime::RuntimeApi,

            >::new(),

            phantom: PhantomData,

        },

        state: Default::default(),

        db_folder_cleanup_done: false,

        collate_on_tanssi,

        collation_cancellation_constructs: None,

    };

    let state = container_chain_spawner.state.clone();

    task_manager.spawn_essential_handle().spawn(

        "container-chain-spawner-rx-loop",

        None,

        container_chain_spawner.rx_loop(cc_spawn_rx, validator, true),

    );

    task_manager.spawn_essential_handle().spawn(

        "container-chain-spawner-debug-state",

        None,

        monitor::monitor_task(state),

    );

    Ok(task_manager)

}

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

                            Err(e) => {

                                    log::error!("Failed to collect collation info: {:?}", e);

                                    false

    pub fn build(self) -> Arc<dyn OrchestratorChainInterface> {

        Arc::new(OrchestratorChainInProcessInterface::new(

            self.client,

            self.backend,

            self.sync_oracle,

            self.overseer_handle,

        ))

    }

    pub fn build(self) -> Arc<dyn OrchestratorChainInterface> {

        Arc::new(OrchestratorChainSolochainInterface::new(

            self.overseer_handle,

            self.relay_chain_interface,

        ))

    }

    pub fn new(

        full_client: Arc<Client>,

        backend: Arc<FullBackend>,

        sync_oracle: Arc<dyn SyncOracle + Send + Sync>,

        overseer_handle: Handle,

    ) -> Self {

        Self {

            full_client,

            backend,

            sync_oracle,

            overseer_handle,

        }

    }

    fn clone(&self) -> Self {

        Self {

            full_client: self.full_client.clone(),

            backend: self.backend.clone(),

            sync_oracle: self.sync_oracle.clone(),

            overseer_handle: self.overseer_handle.clone(),

        }

    }

    ) -> OrchestratorChainResult<Option<StorageValue>> {

        let state = self.backend.state_at(orchestrator_parent)?;

        state

            .storage(key)

            .map_err(OrchestratorChainError::GenericError)

    }

    ) -> OrchestratorChainResult<StorageProof> {

        let state_backend = self.backend.state_at(orchestrator_parent)?;

        sp_state_machine::prove_read(state_backend, relevant_keys)

            .map_err(OrchestratorChainError::StateMachineError)

    }

    fn overseer_handle(&self) -> OrchestratorChainResult<Handle> {

        Ok(self.overseer_handle.clone())

    }

    ) -> OrchestratorChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {

        let notification_stream = self

            .full_client

            .import_notification_stream()

            .map(|notification| notification.header);

        Ok(Box::pin(notification_stream))

    }

    ) -> OrchestratorChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {

        let notifications_stream =

            self.full_client

                .import_notification_stream()

                .filter_map(|notification| async move {

                    notification.is_new_best.then_some(notification.header)

                });

        Ok(Box::pin(notifications_stream))

    }

    ) -> OrchestratorChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {

        let notification_stream = self

            .full_client

            .finality_notification_stream()

            .map(|notification| notification.header);

        Ok(Box::pin(notification_stream))

    }

    ) -> OrchestratorChainResult<Option<ContainerChainGenesisData>> {

        let runtime_api = self.full_client.runtime_api();

        Ok(runtime_api.genesis_data(orchestrator_parent, para_id)?)

    }

    ) -> OrchestratorChainResult<Vec<Vec<u8>>> {

        let runtime_api = self.full_client.runtime_api();

        Ok(runtime_api.boot_nodes(orchestrator_parent, para_id)?)

    }