pub fn session_to_block(n: u32) -> u32 {

    // let block_number = flashbox_runtime::Period::get() * n;

    let block_number = Babe::current_epoch().duration.saturated_into::<u32>() * n;

    // Add 1 because the block that emits the NewSession event cannot contain any extrinsics,

    // so this is the first block of the new session that can actually be used

    block_number + 1

}

pub fn babe_authorities() -> Vec<babe_primitives::AuthorityId> {

    Babe::authorities()

        .iter()

        .map(|(key, _)| key.clone())

        .collect()

}

pub fn grandpa_authorities() -> Vec<pallet_grandpa::AuthorityId> {

    Grandpa::grandpa_authorities()

        .iter()

        .map(|(key, _)| key.clone())

        .collect()

}

pub fn authorities_for_container(para_id: ParaId) -> Option<Vec<NimbusId>> {

    let session_index = Session::current_index();

    TanssiAuthorityAssignment::collator_container_chain(session_index)

        .expect("authorities should be set")

        .container_chains

        .get(&para_id)

        .cloned()

}

pub fn run_to_session(n: u32) {

    run_to_block(session_to_block(n));

}

pub fn run_to_block(n: u32) -> BTreeMap<u32, RunSummary> {

    let current_block_number = System::block_number();

    assert!(

        current_block_number < n,

    let mut summaries = BTreeMap::new();

    while System::block_number() < n {

        let summary = run_block();

        let block_number = System::block_number();

        summaries.insert(block_number, summary);

    }

    summaries

}

pub fn get_genesis_data_with_validation_code() -> (ContainerChainGenesisData, Vec<u8>) {

    let validation_code = mock_validation_code().0;

    let genesis_data = ContainerChainGenesisData {

        storage: vec![(b":code".to_vec(), validation_code.clone()).into()],

        name: Default::default(),

        id: Default::default(),

        fork_id: Default::default(),

        extensions: vec![],

        properties: Default::default(),

    };

    (genesis_data, validation_code)

}

pub fn insert_authorities_and_slot_digests(slot: u64) {

    let pre_digest = Digest {

        logs: vec![DigestItem::PreRuntime(

            BABE_ENGINE_ID,

            PreDigest::SecondaryPlain(SecondaryPlainPreDigest {

                slot: slot.into(),

                authority_index: 0,

            })

            .encode(),

        )],

    };

    System::reset_events();

    System::initialize(

        &(System::block_number() + 1),

        &System::parent_hash(),

        &pre_digest,

    );

}

    Start(u32),

    End(u32),

    fn assert_can_advance(&self, new_state: &RunBlockState) {

        match self {

            RunBlockState::Start(n) => {

                assert_eq!(

                    new_state,

                    &RunBlockState::End(*n),

            RunBlockState::End(n) => {

                assert_eq!(

                    new_state,

                    &RunBlockState::Start(*n + 1),

    }

fn advance_block_state_machine(new_state: RunBlockState) {

    if frame_support::storage::unhashed::exists(b"__mock_is_xcm_test") {

    }

    let old_state: RunBlockState =

        frame_support::storage::unhashed::get(b"__mock_debug_block_state").unwrap_or(

            // Initial state is expecting a call to start() with block number 1, so old state should be

            // end of block 0

            RunBlockState::End(0),

        );

    old_state.assert_can_advance(&new_state);

    frame_support::storage::unhashed::put(b"__mock_debug_block_state", &new_state);

}

pub fn start_block() -> RunSummary {

    let block_number = System::block_number();

    advance_block_state_machine(RunBlockState::Start(block_number + 1));

    insert_authorities_and_slot_digests(current_slot() + 1);

    // Initialize the new block

    Babe::on_initialize(System::block_number());

    ContainerRegistrar::on_initialize(System::block_number());

    Session::on_initialize(System::block_number());

    Initializer::on_initialize(System::block_number());

    TanssiCollatorAssignment::on_initialize(System::block_number());

    let current_issuance = Balances::total_issuance();

    InflationRewards::on_initialize(System::block_number());

    let new_issuance = Balances::total_issuance();

    let maybe_mock_inherent = take_new_inherent_data();

    if let Some(mock_inherent_data) = maybe_mock_inherent {

        set_paras_inherent(mock_inherent_data);

    }

    RunSummary {

        inflation: new_issuance - current_issuance,

    }

}

pub fn end_block() {

    let block_number = System::block_number();

    advance_block_state_machine(RunBlockState::End(block_number));

    // Finalize the block

    Babe::on_finalize(System::block_number());

    Session::on_finalize(System::block_number());

    Grandpa::on_finalize(System::block_number());

    TransactionPayment::on_finalize(System::block_number());

    Initializer::on_finalize(System::block_number());

    ContainerRegistrar::on_finalize(System::block_number());

    TanssiCollatorAssignment::on_finalize(System::block_number());

}

pub fn run_block() -> RunSummary {

    end_block();

    start_block()

}

    fn from(value: (u32, ContainerChainGenesisData, u32, u32)) -> Self {

        Self {

            para_id: value.0,

            genesis_data: value.1,

            block_production_credits: value.2,

            collator_assignment_credits: value.3,

            parathread_params: None,

        }

    }

pub fn default_config() -> pallet_configuration::HostConfiguration {

    pallet_configuration::HostConfiguration {

        max_collators: 100,

        min_orchestrator_collators: 2,

        max_orchestrator_collators: 2,

        collators_per_container: 2,

        full_rotation_period: 0,

        ..Default::default()

    }

}

    fn default() -> Self {

        Self {

            balances: vec![

                // Alice gets 10k extra tokens for her mapping deposit

                (AccountId::from(ALICE), 210_000 * UNIT),

                (AccountId::from(BOB), 100_000 * UNIT),

            ],

            validators: vec![

                (AccountId::from(ALICE), 210 * UNIT),

                (AccountId::from(BOB), 100 * UNIT),

            ],

            collators: Default::default(),

            sudo: Default::default(),

            para_ids: Default::default(),

            config: default_config(),

            relay_config: runtime_parachains::configuration::HostConfiguration {

                scheduler_params: SchedulerParams {

                    num_cores: 6,

                    ..Default::default()

                },

                max_head_data_size: 20500,

                ..Default::default()

            },

            own_para_id: Default::default(),

            next_free_para_id: Default::default(),

            keystore: None,

        }

    }

    pub fn with_balances(mut self, balances: Vec<(AccountId, Balance)>) -> Self {

        self.balances = balances;

        self

    }

    pub fn with_sudo(mut self, sudo: AccountId) -> Self {

        self.sudo = Some(sudo);

        self

    }

    pub fn with_collators(mut self, collators: Vec<(AccountId, Balance)>) -> Self {

        self.collators = collators;

        self

    }

    pub fn with_para_ids(mut self, para_ids: Vec<ParaRegistrationParams>) -> Self {

        self.para_ids = para_ids;

        self

    }

    pub fn with_empty_parachains(mut self, para_ids: Vec<u32>) -> Self {

        self.para_ids = para_ids

            .into_iter()

            .map(|para_id| ParaRegistrationParams {

                para_id,

                genesis_data: empty_genesis_data(),

                block_production_credits: u32::MAX,

                collator_assignment_credits: u32::MAX,

                parathread_params: None,

            })

            .collect();

        self

    }

    pub fn with_additional_empty_parathreads(mut self, para_ids: Vec<u32>) -> Self {

        self.para_ids = self

            .para_ids

            .iter()

            .cloned()

            .chain(para_ids.into_iter().map(|para_id| ParaRegistrationParams {

                para_id,

                genesis_data: empty_genesis_data(),

                block_production_credits: u32::MAX,

                collator_assignment_credits: u32::MAX,

                parathread_params: Some(ParathreadParams {

                    slot_frequency: Default::default(),

                }),

            }))

            .collect();

        self

    }

    pub fn with_config(mut self, config: pallet_configuration::HostConfiguration) -> Self {

        self.config = config;

        self

    }

    pub fn with_relay_config(

        mut self,

        relay_config: runtime_parachains::configuration::HostConfiguration<BlockNumberFor<Runtime>>,

    ) -> Self {

        self.relay_config = relay_config;

        self

    }

    pub fn with_next_free_para_id(mut self, para_id: ParaId) -> Self {

        self.next_free_para_id = para_id;

        self

    }

    pub fn with_keystore(mut self, keystore: KeystorePtr) -> Self {

        self.keystore = Some(keystore);

        self

    }

    pub fn build_storage(self) -> sp_core::storage::Storage {

        let mut t = frame_system::GenesisConfig::<Runtime>::default()

            .build_storage()

            .unwrap();

        pallet_babe::GenesisConfig::<Runtime> {

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        pallet_balances::GenesisConfig::<Runtime> {

            balances: self.balances,

        }

        .assimilate_storage(&mut t)

        .unwrap();

        // We need to initialize these pallets first. When initializing pallet-session,

        // these values will be taken into account for collator-assignment.

        pallet_registrar::GenesisConfig::<Runtime> {

            para_ids: self

                .para_ids

                .iter()

                .cloned()

                .map(|registered_para| {

                    (

                        registered_para.para_id.into(),

                        registered_para.genesis_data,

                        registered_para.parathread_params,

                    )

                })

                .collect(),

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        // We register mock wasm

        runtime_parachains::paras::GenesisConfig::<Runtime> {

            paras: self

                .para_ids

                .iter()

                .cloned()

                .map(|registered_para| {

                    let para_kind = if registered_para.parathread_params.is_some() {

                        ParaKind::Parathread

                        ParaKind::Parachain

                    (

                        registered_para.para_id.into(),

                        ParaGenesisArgs {

                            validation_code: mock_validation_code(),

                            para_kind,

                            genesis_head: HeadData::from(vec![0u8]),

                        },

                    )

                })

                .collect(),

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        pallet_services_payment::GenesisConfig::<Runtime> {

            para_id_credits: self

                .para_ids

                .clone()

                .into_iter()

                .map(|registered_para| {

                    (

                        registered_para.para_id.into(),

                        registered_para.block_production_credits,

                        registered_para.collator_assignment_credits,

                    )

                        .into()

                })

                .collect(),

        }

        .assimilate_storage(&mut t)

        .unwrap();

        runtime_common::paras_registrar::GenesisConfig::<Runtime> {

            next_free_para_id: self.next_free_para_id,

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        // TODO: add here pallet_services_payment::GenesisConfig

        pallet_configuration::GenesisConfig::<Runtime> {

            config: self.config,

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        runtime_parachains::configuration::GenesisConfig::<Runtime> {

            config: self.relay_config,

        }

        .assimilate_storage(&mut t)

        .unwrap();

        let mut keys: Vec<_> = Vec::new();

        if !self.validators.is_empty() {

            let validator_keys: Vec<_> = self

                .validators

                .clone()

                .into_iter()

                .map(|(account, _balance)| {

                    let authority_keys =

                        get_authority_keys_from_seed(&account.to_string(), self.keystore.as_ref());

                    (

                        account.clone(),

                        account,

                        crate::SessionKeys {

                            babe: authority_keys.babe.clone(),

                            grandpa: authority_keys.grandpa.clone(),

                            para_validator: authority_keys.para_validator.clone(),

                            para_assignment: authority_keys.para_assignment.clone(),

                            authority_discovery: authority_keys.authority_discovery.clone(),

                            beefy: authority_keys.beefy.clone(),

                            nimbus: authority_keys.nimbus.clone(),

                        },

                    )

                })

                .collect();

            keys.extend(validator_keys)

        if !self.collators.is_empty() {

            let invulnerables: Vec<AccountId> = self

                .collators

                .clone()

                .into_iter()

                .map(|(account, _balance)| account)

                .collect();

            pallet_invulnerables::GenesisConfig::<Runtime> {

                invulnerables: invulnerables.clone(),

            }

            .assimilate_storage(&mut t)

            .unwrap();

            // But we also initialize their keys in the session pallet

            // We discard those that had the key initialized already

            // from the validator list

            // in other words, for testing purposes we allow to inject a validator account

            // in the collator list

            let validator_unique_accounts: Vec<_> = self

                .validators

                .iter()

                .map(|(account, _)| account.clone())

                .collect();

            let collator_keys: Vec<_> = self

                .collators

                .into_iter()

                .filter_map(|(account, _balance)| {

                    if validator_unique_accounts.contains(&account) {

                        None

                        let authority_keys =

                            get_authority_keys_from_seed(&account.to_string(), None);

                        Some((

                            account.clone(),

                            account,

                            crate::SessionKeys {

                                babe: authority_keys.babe.clone(),

                                grandpa: authority_keys.grandpa.clone(),

                                para_validator: authority_keys.para_validator.clone(),

                                para_assignment: authority_keys.para_assignment.clone(),

                                authority_discovery: authority_keys.authority_discovery.clone(),

                                beefy: authority_keys.beefy.clone(),

                                nimbus: authority_keys.nimbus.clone(),

                            },

                        ))

                })

                .collect();

            keys.extend(collator_keys)

        }

        pallet_session::GenesisConfig::<Runtime> {

            keys,

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        pallet_sudo::GenesisConfig::<Runtime> { key: self.sudo }

            .assimilate_storage(&mut t)

            .unwrap();

        t

    }

    pub fn build(self) -> sp_io::TestExternalities {

        let keystore = self.keystore.clone();

        let t = self.build_storage();

        let mut ext = sp_io::TestExternalities::new(t);

        if let Some(keystore) = keystore {

            ext.register_extension(KeystoreExt(keystore));

        }

        ext.execute_with(|| {

            // Start block 1

            start_block();

        });

        ext

    }

pub fn root_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

    <Runtime as frame_system::Config>::RuntimeOrigin::root()

}

pub fn origin_of(account_id: AccountId) -> <Runtime as frame_system::Config>::RuntimeOrigin {

    <Runtime as frame_system::Config>::RuntimeOrigin::signed(account_id)

}

pub fn inherent_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

    <Runtime as frame_system::Config>::RuntimeOrigin::none()

}

pub fn set_author_noting_inherent_data(builder: ParaHeaderSproofBuilder) {

    for (k, v) in builder.key_values() {

        frame_support::storage::unhashed::put_raw(&k, &v);

    }

    assert_ok!(RuntimeCall::AuthorNoting(

        pallet_author_noting::Call::<Runtime>::set_latest_author_data { data: () }

    )

    .dispatch(inherent_origin()));

}

pub fn empty_genesis_data() -> ContainerChainGenesisData {

    ContainerChainGenesisData {

        storage: Default::default(),

        name: Default::default(),

        id: Default::default(),

        fork_id: Default::default(),

        extensions: Default::default(),

        properties: Default::default(),

    }

}

pub fn current_slot() -> u64 {

    Babe::current_slot().into()

}

pub fn block_credits_to_required_balance(number_of_blocks: u32, para_id: ParaId) -> Balance {

    let block_cost = BlockProductionCost::block_cost(&para_id).0;

    u128::from(number_of_blocks).saturating_mul(block_cost)

}

pub fn collator_assignment_credits_to_required_balance(

    number_of_sessions: u32,

    para_id: ParaId,

) -> Balance {

    let collator_assignment_cost = CollatorAssignmentCost::collator_assignment_cost(&para_id).0;

    u128::from(number_of_sessions).saturating_mul(collator_assignment_cost)

}

fn take_new_inherent_data() -> Option<cumulus_primitives_core::relay_chain::InherentData> {

    let data: Option<cumulus_primitives_core::relay_chain::InherentData> =

        frame_support::storage::unhashed::take(b"ParasInherent");

    data

}

pub fn set_new_inherent_data(data: cumulus_primitives_core::relay_chain::InherentData) {

    frame_support::storage::unhashed::put(b"ParasInherent", &data);

}

pub fn set_new_randomness_data(data: Option<[u8; 32]>) {

    pallet_babe::AuthorVrfRandomness::<Runtime>::set(data);

}

pub fn set_paras_inherent(data: cumulus_primitives_core::relay_chain::InherentData) {

    // In order for this inherent to work, we need to match the parent header

    // the parent header does not play a significant role in the rest of the framework so

    // we are simply going to mock it

    System::set_parent_hash(data.parent_header.hash());

    assert_ok!(

        RuntimeCall::ParaInherent(parachains_paras_inherent::Call::<Runtime>::enter { data })

            .dispatch(inherent_origin())

    );

    frame_support::storage::unhashed::kill(&frame_support::storage::storage_prefix(

        b"ParaInherent",

        b"Included",

    ));

}

pub fn mock_validation_code() -> ValidationCode {

    ValidationCode(vec![1; 10])

}

    pub(crate) fn new() -> Self {

        ParasInherentTestBuilder {

            block_number: Zero::zero(),

            backed_and_concluding_paras: Default::default(),

            backed_in_inherent_paras: Default::default(),

            _phantom: core::marker::PhantomData::<T>,

        }

    }

    pub(crate) fn set_backed_and_concluding_paras(

        mut self,

        backed_and_concluding_paras: BTreeMap<u32, u32>,

    ) -> Self {

        self.backed_and_concluding_paras = backed_and_concluding_paras;

        self

    }

    pub(crate) fn header(block_number: BlockNumberFor<T>) -> HeaderFor<T> {

        HeaderFor::<T>::new(

            block_number,       // `block_number`,

            Default::default(), // `extrinsics_root`,

            Default::default(), // `storage_root`,

            Default::default(), // `parent_hash`,

            Default::default(), // digest,

        )

    }

    pub(crate) fn fallback_max_validators() -> u32 {

        runtime_parachains::configuration::ActiveConfig::<T>::get()

            .max_validators

            .unwrap_or(200)

    }

    fn max_validators(&self) -> u32 {

        Self::fallback_max_validators()

    }

    pub(crate) fn fallback_max_validators_per_core() -> u32 {

        runtime_parachains::configuration::ActiveConfig::<T>::get()

            .scheduler_params

            .max_validators_per_core

            .unwrap_or(5)

    }

    fn max_validators_per_core(&self) -> u32 {

        Self::fallback_max_validators_per_core()

    }

    pub(crate) fn max_cores(&self) -> u32 {

        self.max_validators() / self.max_validators_per_core()

    }

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

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

        for i in 0..cores {

            if i < used_cores {

                bitfields.push(true);

            } else {

                bitfields.push(false)

        bitfields.into()

    }

    pub fn mock_head_data() -> HeadData {

        let max_head_size =

            runtime_parachains::configuration::ActiveConfig::<T>::get().max_head_data_size;

        HeadData(vec![0xFF; max_head_size as usize])

    }

    fn relay_parent_number(&self) -> u32 {

        (Self::block_number() - One::one())

            .try_into()

            .map_err(|_| ())

            .expect("Self::block_number() is u32")

    }

    fn create_backed_candidates(

        &self,

        paras_with_backed_candidates: &BTreeMap<u32, u32>,

    ) -> Vec<BackedCandidate<T::Hash>> {

        let current_session = runtime_parachains::shared::CurrentSessionIndex::<T>::get();

        // We need to refetch validators since they have been shuffled.

        let validators_shuffled =

            runtime_parachains::session_info::Sessions::<T>::get(current_session)

                .unwrap()

                .validators

                .clone();

        let config = runtime_parachains::configuration::ActiveConfig::<T>::get();

        let mut current_core_idx = 0u32;

        paras_with_backed_candidates

            .iter()

            .flat_map(|(seed, num_votes)| {

                assert!(*num_votes <= validators_shuffled.len() as u32);

                let para_id = ParaId::from(*seed);

                let prev_head_non_mut = runtime_parachains::paras::Heads::<T>::get(para_id);

                let prev_head = prev_head_non_mut.unwrap_or(Self::mock_head_data());

                // How many chained candidates we want to build ?

                (0..1)

                    .map(|chain_idx| {

                        let core_idx = CoreIndex::from(current_core_idx);

                        // Advance core index.

                        current_core_idx += 1;

                        let group_idx =

                            Self::group_assigned_to_core(core_idx, Self::block_number())

                                .unwrap_or_else(|| {

                                });

                        let header = Self::header(Self::block_number());

                        let relay_parent = header.hash();

                        // Set the head data so it can be used while validating the signatures on

                        // the candidate receipt.

                        let mut head_data = Self::mock_head_data();

                        if chain_idx == 0 {

                            // Only first parahead of the chain needs to be set in storage.

                            Self::heads_insert(&para_id, prev_head.clone());

                        } else {

                        let persisted_validation_data = PersistedValidationData::<T::Hash> {

                            // To form a chain we set parent head to previous block if any, or

                            // default to what is in storage already setup.

                            parent_head: prev_head.clone(),

                            relay_parent_number: self.relay_parent_number() + 1,

                            relay_parent_storage_root: Default::default(),

                            max_pov_size: config.max_pov_size,

                        };

                        let persisted_validation_data_hash = persisted_validation_data.hash();

                        let pov_hash = Default::default();

                        let validation_code_hash = mock_validation_code().hash();

                        let payload =

                            cumulus_primitives_core::relay_chain::collator_signature_payload(

                                &relay_parent,

                                &para_id,

                                &persisted_validation_data_hash,

                                &pov_hash,

                                &validation_code_hash,

                            );

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

                        let signature = collator_pair.sign(&payload);

                        let group_validators = Self::group_validators(group_idx).unwrap();

                        let candidate = CommittedCandidateReceipt::<T::Hash> {

                            descriptor: CandidateDescriptor::<T::Hash> {

                                para_id,

                                relay_parent,

                                collator: collator_pair.public(),

                                persisted_validation_data_hash,

                                pov_hash,

                                erasure_root: Default::default(),

                                signature,

                                para_head: prev_head.hash(),

                                validation_code_hash,

                            },

                            commitments: CandidateCommitments::<u32> {

                                upward_messages: Default::default(),

                                horizontal_messages: Default::default(),

                                new_validation_code: None,

                                head_data: prev_head.clone(),

                                processed_downward_messages: 0,

                                hrmp_watermark: self.relay_parent_number() + 1,

                            },

                        };

                        let candidate_hash = candidate.hash();

                        let validity_votes: Vec<_> = group_validators

                            .iter()

                            .take(*num_votes as usize)

                            .map(|val_idx| {

                                let public = validators_shuffled.get(*val_idx).unwrap();

                                let signature_ctx = SigningContext {

                                    parent_hash: Self::header(Self::block_number()).hash(),

                                    session_index: Session::current_index(),

                                };

                                let sig = UncheckedSigned::<CompactStatement>::benchmark_sign(

                                    public,

                                    CompactStatement::Valid(candidate_hash),

                                    &signature_ctx,

                                    *val_idx,

                                )

                                .benchmark_signature();

                                ValidityAttestation::Explicit(sig.clone())

                            })

                            .collect();

                        // Check if the elastic scaling bit is set, if so we need to supply the core

                        // index in the generated candidate.

                        let core_idx = runtime_parachains::configuration::ActiveConfig::<T>::get()

                            .node_features

                            .get(FeatureIndex::ElasticScalingMVP as usize)

                            .map(|_the_bit| core_idx);

                        BackedCandidate::<T::Hash>::new(

                            candidate,

                            validity_votes,

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

                            core_idx,

                        )

                    })

                    .collect::<Vec<_>>()

            })

            .collect()

    }

    pub(crate) fn group_assigned_to_core(

        core: CoreIndex,

        at: BlockNumberFor<T>,

    ) -> Option<GroupIndex> {

        let config = runtime_parachains::configuration::ActiveConfig::<T>::get();

        let session_start_block = runtime_parachains::scheduler::SessionStartBlock::<T>::get();

        if at < session_start_block {

        }

        let validator_groups = runtime_parachains::scheduler::ValidatorGroups::<T>::get();

        if core.0 as usize >= validator_groups.len() {

        }

        let rotations_since_session_start: BlockNumberFor<T> =

            (at - session_start_block) / config.scheduler_params.group_rotation_frequency;

        let rotations_since_session_start =

            <BlockNumberFor<T> as TryInto<u32>>::try_into(rotations_since_session_start)

                .unwrap_or(0);

        // Error case can only happen if rotations occur only once every u32::max(),

        // so functionally no difference in behavior.

        let group_idx =

            (core.0 as usize + rotations_since_session_start as usize) % validator_groups.len();

        Some(GroupIndex(group_idx as u32))

    }

    pub(crate) fn group_validators(group_index: GroupIndex) -> Option<Vec<ValidatorIndex>> {

        runtime_parachains::scheduler::ValidatorGroups::<T>::get()

            .get(group_index.0 as usize)

            .cloned()

    }

    pub fn heads_insert(para_id: &ParaId, head_data: HeadData) {

        runtime_parachains::paras::Heads::<T>::insert(para_id, head_data);

    }

    pub(crate) fn build(self) -> ParachainsInherentData<HeaderFor<T>> {

        let current_session = runtime_parachains::shared::CurrentSessionIndex::<T>::get();

        // We need to refetch validators since they have been shuffled.

        let validators = runtime_parachains::session_info::Sessions::<T>::get(current_session)

            .unwrap()

            .validators

            .clone();

        let max_cores = self.max_cores() as usize;

        let used_cores =

            self.backed_and_concluding_paras.len() + self.backed_in_inherent_paras.len();

        assert!(used_cores <= max_cores);

        let mut backed_in_inherent = BTreeMap::new();

        backed_in_inherent.append(&mut self.backed_and_concluding_paras.clone());

        backed_in_inherent.append(&mut self.backed_in_inherent_paras.clone());

        let backed_candidates = self.create_backed_candidates(&backed_in_inherent);

        let availability_bitvec = Self::availability_bitvec(used_cores, max_cores);

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

            .iter()

            .enumerate()

            .map(|(i, public)| {

                UncheckedSigned::<AvailabilityBitfield>::benchmark_sign(

                    public,

                    availability_bitvec.clone(),

                    &SigningContext {

                        parent_hash: Self::header(Self::block_number()).hash(),

                        session_index: Session::current_index(),

                    },

                    ValidatorIndex(i as u32),

                )

            })

            .collect();

        ParachainsInherentData {

            bitfields,

            backed_candidates,

            disputes: vec![],

            parent_header: Self::header(Self::block_number()),

        }

    }

    pub(crate) fn block_number() -> BlockNumberFor<T> {

        frame_system::Pallet::<T>::block_number()

    }

pub fn storage_map_final_key<H: frame_support::StorageHasher>(

    pallet_prefix: &str,

    map_name: &str,

    key: &[u8],

) -> Vec<u8> {

    let key_hashed = H::hash(key);

    let pallet_prefix_hashed = frame_support::Twox128::hash(pallet_prefix.as_bytes());

    let storage_prefix_hashed = frame_support::Twox128::hash(map_name.as_bytes());

    let mut final_key = Vec::with_capacity(

        pallet_prefix_hashed.len() + storage_prefix_hashed.len() + key_hashed.as_ref().len(),

    );

    final_key.extend_from_slice(&pallet_prefix_hashed[..]);

    final_key.extend_from_slice(&storage_prefix_hashed[..]);

    final_key.extend_from_slice(key_hashed.as_ref());

    final_key

}

pub fn set_dummy_boot_node(para_manager: RuntimeOrigin, para_id: ParaId) {

    let profile = Profile {

        url:

            b"/ip4/127.0.0.1/tcp/33049/ws/p2p/12D3KooWHVMhQDHBpj9vQmssgyfspYecgV6e3hH1dQVDUkUbCYC9"

                .to_vec()

                .try_into()

                .expect("to fit in BoundedVec"),

        para_ids: ParaIdsFilter::AnyParaId,

        mode: ProfileMode::Bootnode,

        assignment_request: PreserversAssignmentPaymentRequest::Free,

    };

    let profile_id = pallet_data_preservers::NextProfileId::<Runtime>::get();

    let profile_owner = AccountId::new([1u8; 32]);

    DataPreservers::force_create_profile(RuntimeOrigin::root(), profile, profile_owner)

        .expect("profile create to succeed");

    DataPreservers::start_assignment(

        para_manager,

        profile_id,

        para_id,

        PreserversAssignmentPaymentExtra::Free,

    )

    .expect("assignment to work");

    assert!(

        pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id),

}