fn create_dev_rpc_extension<C, P>(

    DevDeps {

        client,

        pool,

        command_sink: maybe_command_sink,

        dev_rpc: maybe_dev_rpc,

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

    io.merge(System::new(client.clone(), pool.clone()).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())?;

    if let Some(dev_rpc_data) = maybe_dev_rpc {

        io.merge(dev_rpc_data.into_rpc())?;

    Ok(io)

}

    pub async fn create<C: HeaderBackend<Block>>(

        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,

        })

    }

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)

}

    pub fn new(

        client: Arc<C>,

        parent: Hash,

        keystore: KeystorePtr,

        upward_messages_receiver: flume::Receiver<Vec<u8>>,

    ) -> Self {

        MockParachainsInherentDataProvider {

            client,

            parent,

            keystore,

            upward_messages_receiver,

        }

    }

    pub async fn create(

        client: Arc<C>,

        parent: Hash,

        keystore: KeystorePtr,

        upward_messages_receiver: flume::Receiver<Vec<u8>>,

    ) -> Result<ParachainsInherentData, InherentError> {

        let parent_header = match client.header(parent) {

            Ok(Some(h)) => h,

        let runtime_api = client.runtime_api();

        // we get all validators

        // we get the current claim queue to know core availability

        let claim_queue = runtime_api.claim_queue(parent).unwrap();

        // we get the validator groups

        let (groups, rotation_info) = runtime_api.validator_groups(parent).unwrap();

        // we calculate rotation since start, which will define the core assignation

        // to validators

        let rotations_since_session_start = (parent_header.number

            - rotation_info.session_start_block)

            / rotation_info.group_rotation_frequency;

        // Get all the available keys in the keystore

        let available_keys = keystore

            .keys(polkadot_primitives::PARACHAIN_KEY_TYPE_ID)

            .unwrap();

        // create a slot number identical to the parent block num

        let slot_number = AuraInherentType::from(u64::from(parent_header.number));

        // create a mocked header

        let parachain_mocked_header = sp_runtime::generic::Header::<u32, BlakeTwo256> {

            parent_hash: Default::default(),

            number: parent_header.number,

            state_root: Default::default(),

            extrinsics_root: Default::default(),

            digest: sp_runtime::generic::Digest {

                logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot_number.encode())],

            },

        };

        // retrieve availability cores

        let availability_cores = runtime_api.availability_cores(parent).unwrap();

        // retrieve current session_idx

        let session_idx = runtime_api.session_index_for_child(parent).unwrap();

        // retrieve all validators

        let all_validators = runtime_api.validators(parent).unwrap();

        // construct full availability bitvec

        let availability_bitvec = availability_bitvec(1, availability_cores.len());

        let signature_ctx = SigningContext {

            parent_hash: parent,

            session_index: session_idx,

        };

        // we generate the availability bitfield sigs

        // TODO: here we assume all validator keys are able to sign with our keystore

        // we need to make sure the key is there before we try to sign

        // this is mostly to indicate that the erasure coding chunks where received by all val

        let bitfields: Vec<UncheckedSigned<AvailabilityBitfield>> = all_validators

            .iter()

            .enumerate()

            .map(|(i, public)| {

                keystore_sign(

                    &keystore,

                    availability_bitvec.clone(),

                    &signature_ctx,

                    ValidatorIndex(i as u32),

                    &public,

                )

                .unwrap()

                .unwrap()

            })

            .collect();

        // generate a random collator pair

        let collator_pair = CollatorPair::generate().0;

        let mut backed_cand: Vec<BackedCandidate<H256>> = vec![];

        for (core, para) in claim_queue {

            let group_assigned_to_core =

                core.0 + rotations_since_session_start % groups.len() as u32;

            // check validator indices associated to the core

            let indices_associated_to_core = groups.get(group_assigned_to_core as usize).unwrap();

            for index in indices_associated_to_core {

                let validator_keys_to_find = all_validators.get(index.0 as usize).unwrap();

                for type_public_pair in &available_keys {

                    if let Ok(validator) =

                        polkadot_primitives::ValidatorId::from_slice(&type_public_pair)

                        if validator_keys_to_find == &validator {

                            // we work with the previous included data

                            let mut persisted_validation_data = runtime_api

                                .persisted_validation_data(

                                    parent,

                                    para[0],

                                    OccupiedCoreAssumption::Included,

                                )

                                .unwrap()

                                .unwrap();

                            // if we dont do this we have a backed candidate every 2 blocks

                            // TODO: figure out why

                            persisted_validation_data.relay_parent_storage_root =

                                parent_header.state_root;

                            let persisted_validation_data_hash = persisted_validation_data.hash();

                            // retrieve the validation code hash

                            let validation_code_hash = runtime_api

                                .validation_code_hash(

                                    parent,

                                    para[0],

                                    OccupiedCoreAssumption::Included,

                                )

                                .unwrap()

                                .unwrap();

                            let pov_hash = Default::default();

                            // generate a fake collator signature

                            let payload = polkadot_primitives::collator_signature_payload(

                                &parent,

                                &para[0],

                                &persisted_validation_data_hash,

                                &pov_hash,

                                &validation_code_hash,

                            );

                            let collator_signature = collator_pair.sign(&payload);

                            let upward_messages = UpwardMessages::try_from(

                                upward_messages_receiver.drain().collect::<Vec<_>>(),

                            )

                            .expect("create upward messages from raw messages");

                            // generate a candidate with most of the values mocked

                            let candidate = CommittedCandidateReceipt::<H256> {

                                descriptor: CandidateDescriptor::<H256> {

                                    para_id: para[0],

                                    relay_parent: parent,

                                    collator: collator_pair.public(),

                                    persisted_validation_data_hash,

                                    pov_hash,

                                    erasure_root: Default::default(),

                                    signature: collator_signature,

                                    para_head: parachain_mocked_header.clone().hash(),

                                    validation_code_hash,

                                },

                                commitments: CandidateCommitments::<u32> {

                                    upward_messages,

                                    horizontal_messages: Default::default(),

                                    new_validation_code: None,

                                    head_data: parachain_mocked_header.clone().encode().into(),

                                    processed_downward_messages: 0,

                                    hrmp_watermark: parent_header.number,

                                },

                            };

                            let candidate_hash = candidate.hash();

                            let payload = CompactStatement::Valid(candidate_hash);

                            let signature_ctx = SigningContext {

                                parent_hash: parent,

                                session_index: session_idx,

                            };

                            // sign the candidate with the validator key

                            let signature = keystore_sign(

                                &keystore,

                                payload,

                                &signature_ctx,

                                *index,

                                &validator,

                            )

                            .unwrap()

                            .unwrap()

                            .benchmark_signature();

                            // construct a validity vote

                            let validity_votes = vec![ValidityAttestation::Explicit(signature)];

                            // push the candidate

                            backed_cand.push(BackedCandidate::<H256>::new(

                                candidate,

                                validity_votes.clone(),

                                bitvec::bitvec![u8, bitvec::order::Lsb0; 1; indices_associated_to_core.len()],

                                Some(core),

                            ));

                        }

        Ok(ParachainsInherentData {

            bitfields: bitfields,

            backed_candidates: backed_cand,

            disputes: Vec::new(),

            parent_header,

        })

    }

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

        let maybe_para_selector = self

            .client

            .get_aux(PARA_INHERENT_SELECTOR_AUX_KEY)

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

        let inherent_data = {

            if let Some(aux) = maybe_para_selector {

                if aux == true.encode() {

                    MockParachainsInherentDataProvider::create(

                        self.client.clone(),

                        self.parent,

                        self.keystore.clone(),

                        self.upward_messages_receiver.clone(),

                    )

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

                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,

        )

    }

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;

    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,

        prometheus_registry.clone(),

    );

    // Create channels for mocked parachain candidates.

    let (downward_mock_para_inherent_sender, downward_mock_para_inherent_receiver) =

        flume::bounded::<Vec<u8>>(100);

    let (upward_mock_sender, upward_mock_receiver) = flume::bounded::<Vec<u8>>(100);

    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_config: 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::with_proof_recording(

            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 keystore_clone = keystore.clone();

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

                    let keystore = keystore_clone.clone();

                    let downward_mock_para_inherent_receiver = downward_mock_para_inherent_receiver.clone();

                    let upward_mock_receiver = upward_mock_receiver.clone();

                    async move {

                        let downward_mock_para_inherent_receiver = downward_mock_para_inherent_receiver.clone();

                        // here we only take the last one

                        let para_inherent_decider_messages: Vec<Vec<u8>> = downward_mock_para_inherent_receiver.drain().collect();

                        let upward_messages_receiver = upward_mock_receiver.clone();

                        if let Some(value) = para_inherent_decider_messages.last() {

                            client_clone

                            .insert_aux(

                                &[(PARA_INHERENT_SELECTOR_AUX_KEY, value.as_slice())],

                                &[],

                            )

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

                        }

                        let parachain = MockParachainsInherentDataProvider::new(

                            client_clone.clone(),

                            parent,

                            keystore,

                            upward_messages_receiver,

                        );

                        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 dev_rpc = if role.clone().is_authority() {

        Some(DevRpc {

            mock_para_inherent_channel: downward_mock_para_inherent_sender,

            upward_message_channel: upward_mock_sender,

        })

    let rpc_extensions_builder = {

        let client = client.clone();

        let transaction_pool = transaction_pool.clone();

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

            let deps = DevDeps {

                client: client.clone(),

                pool: transaction_pool.clone(),

                command_sink: command_sink.clone(),

                dev_rpc: dev_rpc.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::TransactionPoolHandle<Block, FullClient>,

        (

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

            BabeLink<Block>,

            SlotDuration,

            Option<Telemetry>,

        ),

    >,

    Error,

>

where

    ChainSelection: 'static + SelectChain<Block>,

{

    let transaction_pool = sc_transaction_pool::Builder::new(

        task_manager.spawn_essential_handle(),

        client.clone(),

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

    )

    .with_options(config.transaction_pool.clone())

    .with_prometheus(config.prometheus_registry())

    .build();

    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: transaction_pool.into(),

        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

        .executor

        .default_heap_pages

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

        });

    let mut wasm_builder = WasmExecutor::builder()

        .with_execution_method(config.executor.wasm_method)

        .with_onchain_heap_alloc_strategy(heap_pages)

        .with_offchain_heap_alloc_strategy(heap_pages)

        .with_max_runtime_instances(config.executor.max_runtime_instances)

        .with_runtime_cache_size(config.executor.runtime_cache_size);

    if let Some(ref wasmtime_precompiled_path) = config.executor.wasmtime_precompiled {

        wasm_builder = wasm_builder.with_wasmtime_precompiled_path(wasmtime_precompiled_path);

    }

    let executor = wasm_builder.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,

    })

}

fn keystore_sign<H: Encode, Payload: Encode>(

    keystore: &KeystorePtr,

    payload: Payload,

    context: &SigningContext<H>,

    validator_index: ValidatorIndex,

    key: &ValidatorId,

) -> Result<Option<UncheckedSigned<Payload>>, KeystoreError> {

    let data = payload_data(&payload, context);

    let signature = keystore

        .sr25519_sign(ValidatorId::ID, key.as_ref(), &data)?

        .map(|sig| UncheckedSigned::new(payload, validator_index, sig.into()));

    Ok(signature)

}

fn payload_data<H: Encode, Payload: Encode>(

    payload: &Payload,

    context: &SigningContext<H>,

) -> Vec<u8> {

    // equivalent to (`real_payload`, context).encode()

    let mut out = payload.encode_as();

    out.extend(context.encode());

    out

}

fn availability_bitvec(used_cores: usize, total_cores: usize) -> AvailabilityBitfield {

    let mut bitfields = bitvec::bitvec![u8, bitvec::order::Lsb0; 0; 0];

    for i in 0..total_cores {

        if i < used_cores {

            bitfields.push(true);

        } else {

            bitfields.push(false)

    bitfields.into()

}