// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Tanssi is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.

use tokio_util::sync::CancellationToken;

#[allow(deprecated)]

use {

    crate::{

        cli::ContainerChainCli,

        container_chain_spawner::{CcSpawnMsg, ContainerChainSpawner},

    },

    cumulus_client_cli::CollatorOptions,

    cumulus_client_collator::service::CollatorService,

    cumulus_client_consensus_common::{

        ParachainBlockImport as TParachainBlockImport, ParachainBlockImportMarker,

    },

    cumulus_client_consensus_proposer::Proposer,

    cumulus_client_parachain_inherent::{MockValidationDataInherentDataProvider, MockXcmConfig},

    cumulus_client_service::{

        prepare_node_config, start_relay_chain_tasks, DARecoveryProfile, ParachainHostFunctions,

        StartRelayChainTasksParams,

    },

    cumulus_primitives_core::{

        relay_chain::{well_known_keys as RelayWellKnownKeys, CollatorPair},

        ParaId,

    },

    cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface},

    dancebox_runtime::{

        opaque::{Block, Hash},

        RuntimeApi,

    },

    dc_orchestrator_chain_interface::{

        OrchestratorChainError, OrchestratorChainInterface, OrchestratorChainResult, PHash, PHeader,

    },

    dp_slot_duration_runtime_api::TanssiSlotDurationApi,

    futures::{Stream, StreamExt},

    nimbus_primitives::NimbusPair,

    node_common::service::NodeBuilderConfig,

    node_common::service::{ManualSealConfiguration, NodeBuilder, Sealing},

    pallet_registrar_runtime_api::RegistrarApi,

    parity_scale_codec::Encode,

    polkadot_cli::ProvideRuntimeApi,

    polkadot_parachain_primitives::primitives::HeadData,

    polkadot_service::Handle,

    sc_basic_authorship::ProposerFactory,

    sc_client_api::{

        AuxStore, Backend as BackendT, BlockchainEvents, HeaderBackend, UsageProvider,

    },

    sc_consensus::{BasicQueue, BlockImport, ImportQueue},

    sc_executor::{NativeElseWasmExecutor, WasmExecutor},

    sc_network::NetworkBlock,

    sc_network_sync::SyncingService,

    sc_service::{Configuration, SpawnTaskHandle, TFullBackend, TFullClient, TaskManager},

    sc_telemetry::TelemetryHandle,

    sc_transaction_pool::FullPool,

    sp_api::StorageProof,

    sp_consensus::{EnableProofRecording, SyncOracle},

    sp_consensus_slots::{Slot, SlotDuration},

    sp_core::{traits::SpawnEssentialNamed, H256},

    sp_keystore::KeystorePtr,

    sp_state_machine::{Backend as StateBackend, StorageValue},

    std::{pin::Pin, sync::Arc, time::Duration},

    substrate_prometheus_endpoint::Registry,

    tc_consensus::{

        collators::lookahead::{

            self as lookahead_tanssi_aura, Params as LookaheadTanssiAuraParams,

        },

        OrchestratorAuraWorkerAuxData,

    },

    tokio::sync::mpsc::{unbounded_channel, UnboundedSender},

};

mod mocked_relay_keys;

type FullBackend = TFullBackend<Block>;

/// Native executor type.

pub struct ParachainNativeExecutor;

impl sc_executor::NativeExecutionDispatch for ParachainNativeExecutor {

    type ExtendHostFunctions = ParachainHostFunctions;

}

pub struct NodeConfig;

impl NodeBuilderConfig for NodeConfig {

    type Block = Block;

    type RuntimeApi = RuntimeApi;

    type ParachainExecutor = ParachainExecutor;

}

pub struct ContainerChainNodeConfig;

impl NodeBuilderConfig for ContainerChainNodeConfig {

    type Block = Block;

    // TODO: RuntimeApi here should be the subset of runtime apis available for all containers

    // Currently we are using the orchestrator runtime apis

    type RuntimeApi = RuntimeApi;

    type ParachainExecutor = ContainerChainExecutor;

}

// Orchestrator chain types

type ParachainExecutor = NativeElseWasmExecutor<ParachainNativeExecutor>;

pub type ParachainClient = TFullClient<Block, RuntimeApi, ParachainExecutor>;

pub type ParachainBackend = TFullBackend<Block>;

type DevParachainBlockImport = OrchestratorParachainBlockImport<Arc<ParachainClient>>;

type ParachainBlockImport = TParachainBlockImport<Block, Arc<ParachainClient>, ParachainBackend>;

type ParachainProposerFactory =

    ProposerFactory<FullPool<Block, ParachainClient>, ParachainClient, EnableProofRecording>;

// Container chains types

type ContainerChainExecutor = WasmExecutor<ParachainHostFunctions>;

pub type ContainerChainClient = TFullClient<Block, RuntimeApi, ContainerChainExecutor>;

pub type ContainerChainBackend = ParachainBackend;

type ContainerChainBlockImport =

    TParachainBlockImport<Block, Arc<ContainerChainClient>, ContainerChainBackend>;

thread_local!(static TIMESTAMP: std::cell::RefCell<u64> = const { std::cell::RefCell::new(0) });

/// Provide a mock duration starting at 0 in millisecond for timestamp inherent.

/// Each call will increment timestamp by slot_duration making Aura think time has passed.

struct MockTimestampInherentDataProvider;

#[async_trait::async_trait]

impl sp_inherents::InherentDataProvider for MockTimestampInherentDataProvider {

    async fn provide_inherent_data(

        &self,

        inherent_data: &mut sp_inherents::InherentData,

    async fn try_handle_error(

        &self,

        _identifier: &sp_inherents::InherentIdentifier,

        _error: &[u8],

}

/// Background task used to detect changes to container chain assignment,

/// and start/stop container chains on demand. The check runs on every new block.

/// Check the parachain assignment using the orchestrator chain client, and send a `CcSpawnMsg` to

/// start or stop the required container chains.

///

/// Checks the assignment for the next block, so if there is a session change on block 15, this will

/// detect the assignment change after importing block 14.

/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.

///

/// This is the actual implementation that is abstract over the executor and the runtime api.

async fn start_node_impl(

    orchestrator_config: Configuration,

    polkadot_config: Configuration,

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

    collator_options: CollatorOptions,

    para_id: ParaId,

    hwbench: Option<sc_sysinfo::HwBench>,

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

    let parachain_config = prepare_node_config(orchestrator_config);

    if let Some((container_chain_cli, _)) = &mut container_chain_config {

        // If the container chain args have no --wasmtime-precompiled flag, use the same as the orchestrator

        if container_chain_cli

            .base

            .base

            .import_params

            .wasmtime_precompiled

            .is_none()

        {

            container_chain_cli

                .base

                .base

                .import_params

                .wasmtime_precompiled

                .clone_from(&parachain_config.wasmtime_precompiled);

        }

    }

    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)

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

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

    let (cc_spawn_tx, cc_spawn_rx) = unbounded_channel();

    // Create a `NodeBuilder` which helps setup parachain nodes common systems.

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

    };

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

    let sync_keystore = node_builder.keystore_container.keystore();

    let mut collate_on_tanssi: Arc<

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

        } else {

        }

    });

    let announce_block = {

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

    };

    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

        } else {

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

    })?;

    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(

                node_builder.client.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_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(),

            );

        };

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

        collate_on_tanssi = Arc::new(start_collation);

    }

    node_builder.network.start_network.start_network();

    let sync_keystore = node_builder.keystore_container.keystore();

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

    };

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

        // If the orchestrator chain is running as a full-node, we start a full node for the

        // container chain immediately, because only collator nodes detect their container chain

        // assignment so otherwise it will never start.

        if !validator {

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

                // Spawn new container chain node

                cc_spawn_tx

                    .send(CcSpawnMsg::UpdateAssignment {

                        current: Some(container_chain_para_id.into()),

                        next: Some(container_chain_para_id.into()),

                    })

            }

        }

        // Start container chain spawner task. This will start and stop container chains on demand.

        let orchestrator_client = node_builder.client.clone();

        let spawn_handle = node_builder.task_manager.spawn_handle();

        let container_chain_spawner = ContainerChainSpawner {

            orchestrator_chain_interface: orchestrator_chain_interface_builder.build(),

            orchestrator_client,

            orchestrator_tx_pool: node_builder.transaction_pool.clone(),

            container_chain_cli,

            tokio_handle,

            chain_type,

            relay_chain,

            relay_chain_interface,

            collator_key,

            sync_keystore,

            orchestrator_para_id: para_id,

            validator,

            spawn_handle,

            state: Default::default(),

            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),

        );

        node_builder.task_manager.spawn_essential_handle().spawn(

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

            None,

            crate::container_chain_monitor::monitor_task(state),

        )

    }

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

}

// Log string that will be shown for the container chain: `[Container-2000]`.

// This needs to be a separate function because the `prefix_logs_with` macro

// has trouble parsing expressions.

/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.

///

/// This is the actual implementation that is abstract over the executor and the runtime api.

pub async fn start_node_impl_container(

    parachain_config: Configuration,

    orchestrator_client: Arc<ParachainClient>,

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

    relay_chain_interface: Arc<dyn RelayChainInterface>,

    orchestrator_chain_interface: Arc<dyn OrchestratorChainInterface>,

    collator_key: Option<CollatorPair>,

    keystore: KeystorePtr,

    para_id: ParaId,

    orchestrator_para_id: ParaId,

    collator: bool,

) -> sc_service::error::Result<(

    TaskManager,

    Arc<ContainerChainClient>,

    Arc<ParachainBackend>,

)> {

    let parachain_config = prepare_node_config(parachain_config);

    // Create a `NodeBuilder` which helps setup parachain nodes common systems.

    let node_builder = ContainerChainNodeConfig::new_builder(&parachain_config, None)?;

    let (block_import, import_queue) =

        container_chain_import_queue(&parachain_config, &node_builder);

    let import_queue_service = import_queue.service();

    log::info!("are we collators? {:?}", collator);

    let node_builder = node_builder

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

            &parachain_config,

            para_id,

            import_queue,

            relay_chain_interface.clone(),

        )

        .await?;

    let force_authoring = parachain_config.force_authoring;

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

    let rpc_builder = {

        let client = node_builder.client.clone();

        let transaction_pool = node_builder.transaction_pool.clone();

    };

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

    let announce_block = {

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

    };

    let relay_chain_slot_duration = Duration::from_secs(6);

    let overseer_handle = relay_chain_interface

        .overseer_handle()

    let (mut node_builder, _) = 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 collator {

            DARecoveryProfile::Collator

        } else {

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

    })?;

    if collator {

        let collator_key = collator_key

            .clone()

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

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

        let node_client = node_builder.client.clone();

        let node_backend = node_builder.backend.clone();

        start_consensus_container(

            node_client.clone(),

            node_backend.clone(),

            orchestrator_client.clone(),

            orchestrator_tx_pool.clone(),

            block_import.clone(),

            prometheus_registry.clone(),

            node_spawn_handle.clone(),

            relay_chain_interface.clone(),

            orchestrator_chain_interface.clone(),

            node_builder.transaction_pool.clone(),

            node_builder.network.sync_service.clone(),

            keystore.clone(),

            force_authoring,

            relay_chain_slot_duration,

            para_id,

            orchestrator_para_id,

            collator_key.clone(),

            overseer_handle.clone(),

            announce_block.clone(),

        );

    }

    node_builder.network.start_network.start_network();

    Ok((

        node_builder.task_manager,

        node_builder.client,

        node_builder.backend,

    ))

}

/// Build the import queue for the parachain runtime (manual seal).

fn start_consensus_container(

    client: Arc<ContainerChainClient>,

    backend: Arc<FullBackend>,

    orchestrator_client: Arc<ParachainClient>,

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

    block_import: ContainerChainBlockImport,

    prometheus_registry: Option<Registry>,

    telemetry: Option<TelemetryHandle>,

    spawner: SpawnTaskHandle,

    relay_chain_interface: Arc<dyn RelayChainInterface>,

    orchestrator_chain_interface: Arc<dyn OrchestratorChainInterface>,

    transaction_pool: Arc<sc_transaction_pool::FullPool<Block, ContainerChainClient>>,

    sync_oracle: Arc<SyncingService<Block>>,

    keystore: KeystorePtr,

    force_authoring: bool,

    relay_chain_slot_duration: Duration,

    para_id: ParaId,

    orchestrator_para_id: ParaId,

    collator_key: CollatorPair,

    overseer_handle: OverseerHandle,

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

) {

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

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

    let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording(

        spawner.clone(),

        client.clone(),

        transaction_pool,

        prometheus_registry.as_ref(),

        telemetry.clone(),

    );

    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 relay_chain_interace_for_orch = relay_chain_interface.clone();

    let orchestrator_client_for_cidp = orchestrator_client.clone();

    let client_for_cidp = client.clone();

    let client_for_hash_provider = client.clone();

    let client_for_slot_duration = client.clone();

    let params = LookaheadTanssiAuraParams {

                    authorities,

                    latest_header

                );

        block_import,

        para_client: client,

        relay_client: relay_chain_interface,

        sync_oracle,

        keystore,

        collator_key,

        para_id,

        overseer_handle,

        orchestrator_slot_duration: slot_duration,

        force_authoring,

        relay_chain_slot_duration,

        proposer,

        collator_service,

        // Very limited proposal time.

        authoring_duration: Duration::from_millis(500),

        para_backend: backend,

        code_hash_provider,

        // This cancellation token is no-op as it is not shared outside.

        cancellation_token: CancellationToken::new(),

        orchestrator_tx_pool,

        orchestrator_client,

    };

    let (fut, _exit_notification_receiver) =

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

            params,

        );

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

}

/// Start collator task for orchestrator chain.

/// Returns a `CancellationToken` that can be used to cancel the collator task,

/// and a `oneshot::Receiver<()>` that can be used to wait until the task has ended.

                // Fetch duration every block to avoid downtime when passing from 12 to 6s

                    authorities,

                    block_hash

                );

/// Start a parachain node.

pub const SOFT_DEADLINE_PERCENT: sp_runtime::Percent = sp_runtime::Percent::from_percent(100);

/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.

///

/// This is the actual implementation that is abstract over the executor and the runtime api.

pub fn start_dev_node(

    orchestrator_config: Configuration,

    sealing: Sealing,

    hwbench: Option<sc_sysinfo::HwBench>,

    para_id: ParaId,

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

    let parachain_config = prepare_node_config(orchestrator_config);

    // Create a `NodeBuilder` which helps setup parachain nodes common systems.

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

    // This node block import.

    let block_import = DevParachainBlockImport::new(node_builder.client.clone());

    let import_queue = build_manual_seal_import_queue(

        node_builder.client.clone(),

        block_import.clone(),

        &parachain_config,

        node_builder

            .telemetry

            .as_ref()

        &node_builder.task_manager,

    )?;

    // Build a Substrate Network. (not cumulus since it is a dev node, it mocks

    // the relaychain)

    let mut node_builder = node_builder

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

            &parachain_config,

            import_queue,

        )?;

    // If we're running a collator dev node we must install manual seal block

    // production.

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

        command_sink = node_builder.install_manual_seal(ManualSealConfiguration {

            block_import,

            sealing,

            soft_deadline: Some(SOFT_DEADLINE_PERCENT),

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

            consensus_data_provider: Some(Box::new(

                tc_consensus::OrchestratorManualSealAuraConsensusDataProvider::new(

                    node_builder.client.clone(),

                    node_builder.keystore_container.keystore(),

                    para_id,

                ),

            )),

        })?;

    }

    // This node RPC builder.

    let rpc_builder = {

        let client = node_builder.client.clone();

        let transaction_pool = node_builder.transaction_pool.clone();

    };

    // We spawn all the common substrate tasks to properly run a node.

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

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

    // We start the networking part.

    node_builder.network.start_network.start_network();

    Ok(node_builder.task_manager)

}

/// Can be called for a `Configuration` to check if it is a configuration for

/// the orchestrator network.

pub trait IdentifyVariant {

    /// Returns `true` if this is a configuration for a dev network.

    fn is_dev(&self) -> bool;

}

impl IdentifyVariant for Box<dyn sc_service::ChainSpec> {

}

/// Orchestrator Parachain Block import. We cannot use the one in cumulus as it overrides the best

/// chain selection rule

#[derive(Clone)]

pub struct OrchestratorParachainBlockImport<BI> {

    inner: BI,

}

impl<BI> OrchestratorParachainBlockImport<BI> {

    /// Create a new instance.

}

/// We simply rely on the inner

#[async_trait::async_trait]

impl<BI> BlockImport<Block> for OrchestratorParachainBlockImport<BI>

where

    BI: BlockImport<Block> + Send,

{

    type Error = BI::Error;

    async fn check_block(

        &mut self,

        block: sc_consensus::BlockCheckParams<Block>,

    async fn import_block(

        &mut self,

        params: sc_consensus::BlockImportParams<Block>,

}

/// But we need to implement the ParachainBlockImportMarker trait to fullfil

impl<BI> ParachainBlockImportMarker for OrchestratorParachainBlockImport<BI> {}

/// Builder for a concrete relay chain interface, created from a full node. Builds

/// a [`RelayChainInProcessInterface`] to access relay chain data necessary for parachain operation.

///

/// The builder takes a [`polkadot_client::Client`]

/// that wraps a concrete instance. By using [`polkadot_client::ExecuteWithClient`]

/// the builder gets access to this concrete instance and instantiates a [`RelayChainInProcessInterface`] with it.

struct OrchestratorChainInProcessInterfaceBuilder {

    client: Arc<ParachainClient>,

    backend: Arc<FullBackend>,

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

    overseer_handle: Handle,

}

impl OrchestratorChainInProcessInterfaceBuilder {

}

/// Provides an implementation of the [`RelayChainInterface`] using a local in-process relay chain node.

pub struct OrchestratorChainInProcessInterface<Client> {

    pub full_client: Arc<Client>,

    pub backend: Arc<FullBackend>,

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

    pub overseer_handle: Handle,

}

impl<Client> OrchestratorChainInProcessInterface<Client> {

    /// Create a new instance of [`RelayChainInProcessInterface`]