#[frame_support::pallet]

    #[pallet::pallet]

    #[pallet::event]

    #[pallet::generate_deposit(pub(super) fn deposit_event)]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::call]

        pub(crate) fn enough_collators_for_all_chains(

            bulk_paras: &Vec<ChainNumCollators>,

            pool_paras: &Vec<ChainNumCollators>,

            target_session_index: T::SessionIndex,

            number_of_collators: u32,

            collators_per_container: u32,

            collators_per_parathread: u32,

        ) -> bool {

            number_of_collators

                >= T::HostConfiguration::min_collators_for_orchestrator(target_session_index)

                    .saturating_add(collators_per_container.saturating_mul(bulk_paras.len() as u32))

                    .saturating_add(

                        collators_per_parathread.saturating_mul(pool_paras.len() as u32),

                    )

        }

        pub(crate) fn order_paras_with_core_config(

            mut bulk_paras: Vec<ChainNumCollators>,

            mut pool_paras: Vec<ChainNumCollators>,

            core_allocation_configuration: &CoreAllocationConfiguration,

            target_session_index: T::SessionIndex,

            number_of_collators: u32,

            collators_per_container: u32,

            collators_per_parathread: u32,

        ) -> (Vec<ChainNumCollators>, bool) {

            let core_count = core_allocation_configuration.core_count;

            let max_number_of_bulk_paras = core_allocation_configuration

                .max_parachain_percentage

                .mul(core_count);

            let enough_cores_for_bulk_paras = bulk_paras.len() <= max_number_of_bulk_paras as usize;

            let enough_collators = Self::enough_collators_for_all_chains(

                &bulk_paras,

                &pool_paras,

                target_session_index,

                number_of_collators,

                collators_per_container,

                collators_per_parathread,

            );

            let should_charge_tip = !enough_cores_for_bulk_paras || !enough_collators;

            if should_charge_tip {

                bulk_paras.sort_by(|a, b| {

                    T::CollatorAssignmentTip::get_para_tip(b.para_id)

                        .cmp(&T::CollatorAssignmentTip::get_para_tip(a.para_id))

                });

                pool_paras.sort_by(|a, b| {

                    T::CollatorAssignmentTip::get_para_tip(b.para_id)

                        .cmp(&T::CollatorAssignmentTip::get_para_tip(a.para_id))

                });

            }

            bulk_paras.truncate(max_number_of_bulk_paras as usize);

            // We are not truncating pool paras, since their workload is not continuous one core

            // can be shared by many paras during the session.

            let chains: Vec<_> = bulk_paras.into_iter().chain(pool_paras).collect();

            (chains, should_charge_tip)

        }

        pub(crate) fn order_paras(

            bulk_paras: Vec<ChainNumCollators>,

            pool_paras: Vec<ChainNumCollators>,

            target_session_index: T::SessionIndex,

            number_of_collators: u32,

            collators_per_container: u32,

            collators_per_parathread: u32,

        ) -> (Vec<ChainNumCollators>, bool) {

            // Are there enough collators to satisfy the minimum demand?

            let enough_collators_for_all_chain = Self::enough_collators_for_all_chains(

                &bulk_paras,

                &pool_paras,

                target_session_index,

                number_of_collators,

                collators_per_container,

                collators_per_parathread,

            );

            let mut chains: Vec<_> = bulk_paras.into_iter().chain(pool_paras).collect();

            // Prioritize paras by tip on congestion

            // As of now this doesn't distinguish between bulk paras and pool paras

            if !enough_collators_for_all_chain {

                chains.sort_by(|a, b| {

                    T::CollatorAssignmentTip::get_para_tip(b.para_id)

                        .cmp(&T::CollatorAssignmentTip::get_para_tip(a.para_id))

                });

            }

            (chains, !enough_collators_for_all_chain)

        }

        pub fn assign_collators(

            current_session_index: &T::SessionIndex,

            random_seed: [u8; 32],

            collators: Vec<T::AccountId>,

        ) -> SessionChangeOutcome<T> {

            let maybe_core_allocation_configuration = T::CoreAllocationConfiguration::get();

            // We work with one session delay to calculate assignments

            let session_delay = T::SessionIndex::one();

            let target_session_index = current_session_index.saturating_add(session_delay);

            let collators_per_container =

                T::HostConfiguration::collators_per_container(target_session_index);

            let collators_per_parathread =

                T::HostConfiguration::collators_per_parathread(target_session_index);

            // We get the containerChains that we will have at the target session

            let container_chains =

                T::ContainerChains::session_container_chains(target_session_index);

            let num_total_registered_paras = container_chains

                .parachains

                .len()

                .saturating_add(container_chains.parathreads.len())

                as u32;

            let mut container_chain_ids = container_chains.parachains;

            let mut parathreads: Vec<_> = container_chains

                .parathreads

                .into_iter()

                .map(|(para_id, _)| para_id)

                .collect();

            // We read current assigned collators

            let old_assigned = Self::read_assigned_collators();

            let old_assigned_para_ids: BTreeSet<ParaId> =

                old_assigned.container_chains.keys().cloned().collect();

            // Remove the containerChains that do not have enough credits for block production

            T::ParaIdAssignmentHooks::pre_assignment(

                &mut container_chain_ids,

                &old_assigned_para_ids,

            );

            // TODO: parathreads should be treated a bit differently, they don't need to have the same amount of credits

            // as parathreads because they will not be producing blocks on every slot.

            T::ParaIdAssignmentHooks::pre_assignment(&mut parathreads, &old_assigned_para_ids);

            let mut shuffle_collators = None;

            // If the random_seed is all zeros, we don't shuffle the list of collators nor the list

            // of container chains.

            // This should only happen in tests_without_core_config, and in the genesis block.

            if random_seed != [0; 32] {

                let mut rng: ChaCha20Rng = SeedableRng::from_seed(random_seed);

                container_chain_ids.shuffle(&mut rng);

                parathreads.shuffle(&mut rng);

                shuffle_collators = Some(move |collators: &mut Vec<T::AccountId>| {

                    collators.shuffle(&mut rng);

                })

            }

            let orchestrator_chain: ChainNumCollators = if T::ForceEmptyOrchestrator::get() {

                ChainNumCollators {

                    para_id: T::SelfParaId::get(),

                    min_collators: 0u32,

                    max_collators: 0u32,

                    parathread: false,

                }

                ChainNumCollators {

                    para_id: T::SelfParaId::get(),

                    min_collators: T::HostConfiguration::min_collators_for_orchestrator(

                        target_session_index,

                    ),

                    max_collators: T::HostConfiguration::max_collators_for_orchestrator(

                        target_session_index,

                    ),

                    parathread: false,

                }

            let mut bulk_paras = vec![];

            let mut pool_paras = vec![];

            for para_id in &container_chain_ids {

                bulk_paras.push(ChainNumCollators {

                    para_id: *para_id,

                    min_collators: collators_per_container,

                    max_collators: collators_per_container,

                    parathread: false,

                });

            }

            for para_id in &parathreads {

                pool_paras.push(ChainNumCollators {

                    para_id: *para_id,

                    min_collators: collators_per_parathread,

                    max_collators: collators_per_parathread,

                    parathread: true,

                });

            }

            let (chains, need_to_charge_tip) =

                if let Some(core_allocation_configuration) = maybe_core_allocation_configuration {

                    Self::order_paras_with_core_config(

                        bulk_paras,

                        pool_paras,

                        &core_allocation_configuration,

                        target_session_index,

                        collators.len() as u32,

                        collators_per_container,

                        collators_per_parathread,

                    )

                    Self::order_paras(

                        bulk_paras,

                        pool_paras,

                        target_session_index,

                        collators.len() as u32,

                        collators_per_container,

                        collators_per_parathread,

                    )

            let full_rotation =

                T::ShouldRotateAllCollators::should_rotate_all_collators(target_session_index);

            if full_rotation {

                log::info!(

                    "Collator assignment: rotating collators. Session {:?}, Seed: {:?}",

                    current_session_index.encode(),

                log::info!(

                    "Collator assignment: keep old assigned. Session {:?}, Seed: {:?}",

                    current_session_index.encode(),

            let full_rotation_mode = if full_rotation {

                T::HostConfiguration::full_rotation_mode(target_session_index)

                FullRotationModes::keep_all()

            Self::deposit_event(Event::NewPendingAssignment {

                random_seed,

                full_rotation,

                target_session: target_session_index,

                full_rotation_mode: full_rotation_mode.clone(),

            });

            let new_assigned = Assignment::<T>::assign_collators_always_keep_old(

                collators,

                orchestrator_chain,

                chains,

                old_assigned.clone(),

                shuffle_collators,

                full_rotation_mode,

            );

            let mut new_assigned = match new_assigned {

                Ok(x) => x,

                Err(e) => {

                    log::error!(

                        "Error in collator assignment, will keep previous assignment. {:?}",

                    old_assigned.clone()

            let mut assigned_containers = new_assigned.container_chains.clone();

            assigned_containers.retain(|_, v| !v.is_empty());

            let maybe_tip: Option<BalanceOf<T>> = if !need_to_charge_tip {

                None

                assigned_containers

                    .into_keys()

                    .filter_map(T::CollatorAssignmentTip::get_para_tip)

                    .min()

            T::ParaIdAssignmentHooks::post_assignment(

                &old_assigned_para_ids,

                &mut new_assigned.container_chains,

                &maybe_tip,

            );

            Self::store_collator_fullness(

                &new_assigned,

                T::HostConfiguration::max_collators(target_session_index),

            );

            let mut pending = PendingCollatorContainerChain::<T>::get();

            let old_assigned_changed = old_assigned != new_assigned;

            let mut pending_changed = false;

            if let Some(current) = pending.take() {

                pending_changed = true;

                CollatorContainerChain::<T>::put(current);

            }

            if old_assigned_changed {

                pending = Some(new_assigned.clone());

                pending_changed = true;

            }

            if pending_changed {

                PendingCollatorContainerChain::<T>::put(pending);

            }

            if current_session_index == &T::SessionIndex::zero() {

                CollatorContainerChain::<T>::put(new_assigned.clone());

                return SessionChangeOutcome {

                    active_assignment: new_assigned.clone(),

                    next_assignment: new_assigned,

                    num_total_registered_paras,

                };

            }

            SessionChangeOutcome {

                active_assignment: old_assigned,

                next_assignment: new_assigned,

                num_total_registered_paras,

            }

        }

        fn store_collator_fullness(

            new_assigned: &AssignedCollators<T::AccountId>,

            max_collators: u32,

        ) {

            // Count number of assigned collators

            let mut num_collators = 0;

            num_collators.saturating_accrue(new_assigned.orchestrator_chain.len());

            for (_para_id, collators) in &new_assigned.container_chains {

                num_collators.saturating_accrue(collators.len());

            }

            let mut num_collators = num_collators as u32;

            if num_collators > max_collators {

                // Shouldn't happen but just in case

                num_collators = max_collators;

            }

            let ratio = Perbill::from_rational(num_collators, max_collators);

            CollatorFullnessRatio::<T>::put(ratio);

        }

        fn read_assigned_collators() -> AssignedCollators<T::AccountId> {

            let mut pending_collator_list = PendingCollatorContainerChain::<T>::get();

            if let Some(assigned_collators) = pending_collator_list.take() {

                assigned_collators

                CollatorContainerChain::<T>::get()

        }

        pub fn initializer_on_new_session(

            session_index: &T::SessionIndex,

            collators: Vec<T::AccountId>,

        ) -> SessionChangeOutcome<T> {

            let random_seed = T::Randomness::take_randomness();

            let num_collators = collators.len();

            let assigned_collators = Self::assign_collators(session_index, random_seed, collators);

            let num_total_registered_paras = assigned_collators.num_total_registered_paras;

            frame_system::Pallet::<T>::register_extra_weight_unchecked(

                T::WeightInfo::new_session(num_collators as u32, num_total_registered_paras),

                DispatchClass::Mandatory,

            );

            assigned_collators

        }

        pub fn collator_container_chain() -> AssignedCollators<T::AccountId> {

            CollatorContainerChain::<T>::get()

        }

        pub fn pending_collator_container_chain() -> Option<AssignedCollators<T::AccountId>> {

            PendingCollatorContainerChain::<T>::get()

        }

        fn author_for_slot(slot: Slot, para_id: ParaId) -> Option<T::AccountId> {

            let assigned_collators = Pallet::<T>::collator_container_chain();

            let collators = if para_id == T::SelfParaId::get() {

                Some(&assigned_collators.orchestrator_chain)

                assigned_collators.container_chains.get(&para_id)

            if collators.is_empty() {

            }

            let author_index = u64::from(slot) % collators.len() as u64;

            collators.get(author_index as usize).cloned()

        }

    #[pallet::hooks]

        fn on_initialize(n: BlockNumberFor<T>) -> Weight {

            let mut weight = Weight::zero();

            // Account reads and writes for on_finalize

            weight.saturating_accrue(T::Randomness::prepare_randomness_weight(n));

            weight

        }

        fn on_finalize(n: BlockNumberFor<T>) {

            // If the next block is a session change, read randomness and store in pallet storage

            T::Randomness::prepare_randomness(n);

        }

        fn container_chains_with_collators(

            for_session: ForSession,

        ) -> Vec<(ParaId, Vec<T::AccountId>)> {

            // If next session has None then current session data will stay.

            let chains = (for_session == ForSession::Next)

                .then(|| PendingCollatorContainerChain::<T>::get())

                .flatten()

                .unwrap_or_else(|| CollatorContainerChain::<T>::get());

            chains.container_chains.into_iter().collect()

        }

        fn get_all_collators_assigned_to_chains(for_session: ForSession) -> BTreeSet<T::AccountId> {

            let mut all_chains: Vec<T::AccountId> =

                Self::container_chains_with_collators(for_session)

                    .iter()

                    .flat_map(|(_para_id, collators)| collators.iter())

                    .cloned()

                    .collect();

            all_chains.extend(

                Self::collator_container_chain()

                    .orchestrator_chain

                    .iter()

                    .cloned(),

            );

            all_chains.into_iter().collect()

        }

    fn should_rotate_all_collators(session_index: u32) -> bool {

        let period = Period::get();

        if period == 0 {

            false

            session_index % Period::get() == 0

    }

    fn prepare_randomness_weight(_n: BlockNumber) -> Weight {

        Weight::zero()

    }

    fn prepare_randomness(_n: BlockNumber) {}

    fn take_randomness() -> [u8; 32] {

        [0; 32]

    }

    fn prepare_randomness_weight(n: BlockNumber) -> Weight {

        let mut weight = Weight::zero();

        if T::should_end_session(n.saturating_add(One::one())) {

            weight.saturating_accrue(Runtime::DbWeight::get().reads_writes(1, 1));

        }

        weight

    }

    fn prepare_randomness(n: BlockNumber) {

        if T::should_end_session(n.saturating_add(One::one())) {

            let random_seed = T::get_randomness();

            Randomness::<Runtime>::put(random_seed);

        }

    }

    fn take_randomness() -> [u8; 32] {

        Randomness::<Runtime>::take()

    }

    fn prepare_randomness_weight(_n: BlockNumber) -> Weight {

        Weight::zero()

    }

    fn prepare_randomness(_n: BlockNumber) {}

    fn take_randomness() -> [u8; 32] {

        #[cfg(feature = "runtime-benchmarks")]

        if let Some(x) =

            frame_support::storage::unhashed::take(b"__bench_collator_assignment_randomness")

        {

            return x;

        }

        T::get()

    }