pub fn read_last_entropy() -> [u8; 32] {

    let mut last = [0u8; 32];

    sp_io::storage::read(well_known_keys::INTRABLOCK_ENTROPY, &mut last[..], 0);

    last

}

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 get_beefy_digest(log: ConsensusLog<BeefyId>) -> DigestItem {

    DigestItem::Consensus(BEEFY_ENGINE_ID, log.encode())

}

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: BoundedVec::try_from(vec![(b":code".to_vec(), validation_code.clone()).into()])

            .unwrap(),

        name: Default::default(),

        id: Default::default(),

        fork_id: Default::default(),

        extensions: BoundedVec::try_from(vec![]).unwrap(),

        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 mock_inherent_data: Option<cumulus_primitives_core::relay_chain::vstaging::InherentData> =

        if is_para_inherent_enabled() {

            Some(

                take_new_inherent_data()

                    .unwrap_or(ParasInherentTestBuilder::<Runtime>::new().build()),

            )

            None

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

    Authorship::on_initialize(System::block_number());

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

    ExternalValidatorSlashes::on_initialize(System::block_number());

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

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

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

    MessageQueue::on_initialize(System::block_number());

    let current_issuance = Balances::total_issuance();

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

    let new_issuance = Balances::total_issuance();

    if let Some(mock_inherent_data) = mock_inherent_data {

        set_paras_inherent(mock_inherent_data);

    }

    Beefy::on_initialize(System::block_number());

    Mmr::on_initialize(System::block_number());

    BeefyMmrLeaf::on_initialize(System::block_number());

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

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

    Beefy::on_finalize(System::block_number());

    Mmr::on_finalize(System::block_number());

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

            ],

            external_validators: vec![],

            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,

            safe_xcm_version: Default::default(),

            inherent_data_enabled: false,

        }

    }

    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_validators(mut self, validators: Vec<(AccountId, Balance)>) -> Self {

        self.validators = validators;

        self

    }

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

        self.external_validators = validators;

        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 with_inherent_data_enabled(mut self) -> Self {

        self.inherent_data_enabled = true;

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

        pallet_xcm::GenesisConfig::<Runtime> {

            safe_xcm_version: self.safe_xcm_version,

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

        let mut non_authority_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());

                    if let Some(keystore) = self.keystore.as_ref() {

                        insert_authority_keys_into_keystore(&account.to_string(), keystore)

                    }

                    (

                        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.external_validators.is_empty() {

            let validator_keys: Vec<_> = self

                .external_validators

                .clone()

                .into_iter()

                .map(|(account, _balance)| {

                    let authority_keys = get_authority_keys_from_seed(&account.to_string());

                    if let Some(keystore) = 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());

                        if let Some(keystore) = self.keystore.as_ref() {

                        }

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

            non_authority_keys.extend(collator_keys)

        }

        pallet_external_validators::GenesisConfig::<Runtime> {

            skip_external_validators: false,

            whitelisted_validators: self

                .validators

                .iter()

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

                .collect(),

            external_validators: self

                .external_validators

                .iter()

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

                .collect(),

        }

        .assimilate_storage(&mut t)

        .unwrap();

        pallet_session::GenesisConfig::<Runtime> {

            keys,

            non_authority_keys,

        }

        .assimilate_storage(&mut t)

        .unwrap();

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

            .assimilate_storage(&mut t)

            .unwrap();

        snowbridge_pallet_system::GenesisConfig::<Runtime> {

            // This is irrelevant, we can put any number here

            // as long as it is a non-used para id

            para_id: 1000u32.into(),

            asset_hub_para_id: 1001u32.into(),

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        if self.safe_xcm_version.is_some() {

        }

        t.top.insert(

            b"ParasInherentEnabled".to_vec(),

            self.inherent_data_enabled.encode(),

        );

        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::vstaging::InherentData>

{

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

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

    data

}

fn is_para_inherent_enabled() -> bool {

    let enabled: Option<bool> = frame_support::storage::unhashed::get(b"ParasInherentEnabled");

    enabled.unwrap_or(false)

}

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

    frame_support::storage::unhashed::put(b"ParasInherentData", &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::vstaging::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,

        )

    }

    fn availability_bitvec(concluding_cores: &BTreeSet<u32>, cores: usize) -> AvailabilityBitfield {

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

        for i in 0..cores {

            if concluding_cores.contains(&(i as u32)) {

                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 mut past_code_meta =

                            paras::ParaPastCodeMeta::<BlockNumberFor<T>>::default();

                        past_code_meta.note_replacement(0u32.into(), 0u32.into());

                         */

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

                        let descriptor = if true

                            CandidateDescriptorV2::new(

                                para_id,

                                relay_parent,

                                core_idx,

                                current_session,

                                persisted_validation_data_hash,

                                pov_hash,

                                Default::default(),

                                prev_head.hash(),

                                validation_code_hash,

                            )

                        let mut candidate = CommittedCandidateReceiptV2::<T::Hash> {

                            descriptor,

                            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,

                            },

                        };

                        if true

                        {

                            // `UMPSignal` separator.

                            candidate

                                .commitments

                                .upward_messages

                                .force_push(UMP_SEPARATOR);

                            // `SelectCore` commitment.

                            // Claim queue offset must be `0` so this candidate is for the very

                            // next block.

                            candidate.commitments.upward_messages.force_push(

                                UMPSignal::SelectCore(CoreSelector(chain_idx), ClaimQueueOffset(0))

                                    .encode(),

                            );

                        }

                        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)

                            .and_then(|the_bit| if *the_bit { Some(core_idx) } else { None });

                        assert_eq!(group_validators.len(), 1);

                        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 {

        }