#[frame_support::pallet]

    #[pallet::pallet]

    #[pallet::genesis_build]

        fn build(&self) {

            // Sort para ids and detect duplicates, but do it using a vector of

            // references to avoid cloning the genesis data, which may be big.

            let mut para_ids: Vec<&_> = self.para_ids.iter().collect();

            para_ids.sort_by(|a, b| a.0.cmp(&b.0));

            para_ids.dedup_by(|a, b| {

                if a.0 == b.0 {

                    panic!("Duplicate para_id: {}", u32::from(a.0));

                    false

                }

            });

            let mut bounded_para_ids = BoundedVec::default();

            for (para_id, genesis_data) in para_ids {

                bounded_para_ids

                    .try_push(*para_id)

                    .expect("too many para ids in genesis: bounded vec full");

                let genesis_data_size = genesis_data.encoded_size();

                if genesis_data_size > T::MaxGenesisDataSize::get() as usize {

                    panic!(

                        "genesis data for para_id {:?} is too large: {} bytes (limit is {})",

                        u32::from(*para_id),

                        genesis_data_size,

                        T::MaxGenesisDataSize::get()

                    );

                }

                <ParaGenesisData<T>>::insert(para_id, genesis_data);

            <RegisteredParaIds<T>>::put(bounded_para_ids);

        }

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[derive(Default, Clone, Encode, Decode, RuntimeDebug, PartialEq, scale_info::TypeInfo)]

    #[pallet::storage]

    #[pallet::storage]

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

        /// A new para id has been registered. [para_id]

        /// A para id has been deregistered. [para_id]

        /// A new para id is now valid for collating. [para_id]

        /// A para id has been paused from collating.

    #[pallet::error]

        RegistrarDeposit,

    #[pallet::hooks]

    #[pallet::call]

        ) -> DispatchResult {

            let account = ensure_signed(origin)?;

            Self::do_register(account, para_id, genesis_data)?;

            Self::deposit_event(Event::ParaIdRegistered { para_id });

            Ok(())

        pub fn deregister(origin: OriginFor<T>, para_id: ParaId) -> DispatchResult {

            T::RegistrarOrigin::ensure_origin(origin)?;

            Self::do_deregister(para_id)?;

            Ok(())

        pub fn mark_valid_for_collating(origin: OriginFor<T>, para_id: ParaId) -> DispatchResult {

            T::MarkValidForCollatingOrigin::ensure_origin(origin)?;

            Self::do_mark_valid_for_collating(para_id)?;

            Ok(())

        pub fn pause_container_chain(origin: OriginFor<T>, para_id: ParaId) -> DispatchResult {

            T::RegistrarOrigin::ensure_origin(origin)?;

            Self::schedule_paused_parachain_change(|para_ids, paused| {

                match paused.binary_search(&para_id) {

                    Ok(_) => return Err(Error::<T>::ParaIdAlreadyPaused.into()),

                    Err(index) => {

                        paused

                            .try_insert(index, para_id)

                            .map_err(|_e| Error::<T>::ParaIdListFull)?;

                match para_ids.binary_search(&para_id) {

                    Ok(index) => {

                        para_ids.remove(index);

                    }

                    Err(_) => return Err(Error::<T>::ParaIdNotRegistered.into()),

                Self::deposit_event(Event::ParaIdPaused { para_id });

                Ok(())

            })?;

            Ok(())

        pub fn unpause_container_chain(origin: OriginFor<T>, para_id: ParaId) -> DispatchResult {

            T::RegistrarOrigin::ensure_origin(origin)?;

            Self::schedule_paused_parachain_change(|para_ids, paused| {

                match paused.binary_search(&para_id) {

                    Ok(index) => {

                        paused.remove(index);

                    }

                    Err(_) => return Err(Error::<T>::ParaIdNotPaused.into()),

                match para_ids.binary_search(&para_id) {

                    Err(index) => {

                        para_ids

                            .try_insert(index, para_id)

                            .map_err(|_e| Error::<T>::ParaIdListFull)?;

                Self::deposit_event(Event::ParaIdUnpaused { para_id });

                Ok(())

            })?;

            Ok(())

        ) -> DispatchResult {

            let account = ensure_signed(origin)?;

            Self::do_register(account, para_id, genesis_data)?;

            let params = ParathreadParamsTy { slot_frequency };

            ParathreadParams::<T>::insert(para_id, params);

            Self::deposit_event(Event::ParaIdRegistered { para_id });

            Ok(())

        ) -> DispatchResult {

            T::RegistrarOrigin::ensure_origin(origin)?;

            Self::schedule_parathread_params_change(para_id, |params| {

                params.slot_frequency = slot_frequency;

                Self::deposit_event(Event::ParathreadParamsChanged { para_id });

                Ok(())

            })?;

            Ok(())

        ) -> DispatchResult {

            let origin = ensure_signed(origin)?;

            let creator =

                RegistrarDeposit::<T>::get(para_id).map(|deposit_info| deposit_info.creator);

            ensure!(Some(origin) == creator, Error::<T>::NotParaCreator);

            ParaManager::<T>::insert(para_id, manager_address.clone());

            Self::deposit_event(Event::<T>::ParaManagerChanged {

                para_id,

                manager_address,

            });

            Ok(())

        ) -> DispatchResult {

            let account = T::RegisterWithRelayProofOrigin::ensure_origin(origin)?;

            let relay_storage_root =

                T::RelayStorageRootProvider::get_relay_storage_root(relay_proof_block_number)

                    .ok_or(Error::<T>::RelayStorageRootNotFound)?;

            let relay_state_proof =

                GenericStateProof::<cumulus_primitives_core::relay_chain::Block>::new(

                    relay_storage_root,

                    relay_storage_proof,

                )

                .map_err(|_| Error::<T>::InvalidRelayStorageProof)?;

            let bytes = para_id.twox_64_concat();

            let key = [REGISTRAR_PARAS_INDEX, bytes.as_slice()].concat();

            let relay_para_info = relay_state_proof

                .read_entry::<ParaInfo<

                    cumulus_primitives_core::relay_chain::AccountId,

                    cumulus_primitives_core::relay_chain::Balance,

                >>(key.as_slice(), None)

                .map_err(|_| Error::<T>::InvalidRelayStorageProof)?;

            let relay_manager = relay_para_info.manager;

            // Verify manager signature

            let signature_msg = Self::relay_signature_msg(para_id, &account, relay_storage_root);

            if !manager_signature.verify(&*signature_msg, &relay_manager) {

                return Err(Error::<T>::InvalidRelayManagerSignature.into());

            }

            Self::do_register(account, para_id, genesis_data)?;

            if let Some(parathread_params) = parathread_params {

            }

            Self::deposit_event(Event::ParaIdRegistered { para_id });

            Ok(())

        ) -> DispatchResult {

            let account = T::RegisterWithRelayProofOrigin::ensure_origin(origin)?;

            let relay_storage_root =

                T::RelayStorageRootProvider::get_relay_storage_root(relay_proof_block_number)

                    .ok_or(Error::<T>::RelayStorageRootNotFound)?;

            let relay_state_proof =

                GenericStateProof::<cumulus_primitives_core::relay_chain::Block>::new(

                    relay_storage_root,

                    relay_storage_proof,

                )

                .map_err(|_| Error::<T>::InvalidRelayStorageProof)?;

            let bytes = para_id.twox_64_concat();

            let key = [REGISTRAR_PARAS_INDEX, bytes.as_slice()].concat();

            let relay_para_info = relay_state_proof

                .read_optional_entry::<ParaInfo<

                    cumulus_primitives_core::relay_chain::AccountId,

                    cumulus_primitives_core::relay_chain::Balance,

                >>(key.as_slice())

                .map_err(|_| Error::<T>::InvalidRelayStorageProof)?;

            if relay_para_info.is_some() {

                return Err(Error::<T>::ParaStillExistsInRelay.into());

            }

            if let Some(asset_info) = RegistrarDeposit::<T>::take(para_id) {

                // Slash deposit from parachain creator

                // TODO: error handling

                let _ = T::Currency::transfer_on_hold(

                    &HoldReason::RegistrarDeposit.into(),

                    &asset_info.creator,

                    &account,

                    asset_info.deposit,

                    Precision::Exact,

                    Restriction::Free,

                    Fortitude::Force,

                );

            }

            Self::do_deregister(para_id)?;

            Ok(())

        pub fn is_para_manager(para_id: &ParaId, account: &T::AccountId) -> bool {

            if let Some(manager) = ParaManager::<T>::get(para_id) {

                manager == *account

        }

        fn do_register(

            account: T::AccountId,

            para_id: ParaId,

            genesis_data: ContainerChainGenesisData<T::MaxLengthTokenSymbol>,

        ) -> DispatchResult {

            let deposit = T::DepositAmount::get();

            // Verify we can hold

            if !T::Currency::can_hold(&HoldReason::RegistrarDeposit.into(), &account, deposit) {

            }

            // Check if the para id is already registered by looking at the genesis data

            if ParaGenesisData::<T>::contains_key(para_id) {

                return Err(Error::<T>::ParaIdAlreadyRegistered.into());

            }

            // Check if the para id is already in PendingVerification (unreachable)

            let is_pending_verification = PendingVerification::<T>::take(para_id).is_some();

            if is_pending_verification {

            }

            // Insert para id into PendingVerification

            PendingVerification::<T>::insert(para_id, ());

            // The actual registration takes place 2 sessions after the call to

            // `mark_valid_for_collating`, but the genesis data is inserted now.

            // This is because collators should be able to start syncing the new container chain

            // before the first block is mined. However, we could store the genesis data in a

            // different key, like PendingParaGenesisData.

            // TODO: for benchmarks, this call to .encoded_size is O(n) with respect to the number

            // of key-values in `genesis_data.storage`, even if those key-values are empty. And we

            // won't detect that the size is too big until after iterating over all of them, so the

            // limit in that case would be the transaction size.

            let genesis_data_size = genesis_data.encoded_size();

            if genesis_data_size > T::MaxGenesisDataSize::get() as usize {

                return Err(Error::<T>::GenesisDataTooBig.into());

            }

            // Hold the deposit, we verified we can do this

            T::Currency::hold(&HoldReason::RegistrarDeposit.into(), &account, deposit)?;

            RegistrarDeposit::<T>::insert(

                para_id,

                DepositInfo {

                    creator: account.clone(),

                    deposit,

                },

            );

            ParaGenesisData::<T>::insert(para_id, genesis_data);

            ParaManager::<T>::insert(para_id, account);

            Ok(())

        }

        fn do_deregister(para_id: ParaId) -> DispatchResult {

            // Check if the para id is in "PendingVerification".

            // This is a special case because then we can remove it immediately, instead of waiting 2 sessions.

            let is_pending_verification = PendingVerification::<T>::take(para_id).is_some();

            if is_pending_verification {

                Self::deposit_event(Event::ParaIdDeregistered { para_id });

                // Cleanup immediately

                Self::cleanup_deregistered_para_id(para_id);

            } else {

                Self::schedule_paused_parachain_change(|para_ids, paused| {

                    // We have to find out where, in the sorted vec the para id is, if anywhere.

                    match para_ids.binary_search(&para_id) {

                        Ok(index) => {

                            para_ids.remove(index);

                        }

                            match paused.binary_search(&para_id) {

                                Ok(index) => {

                                    paused.remove(index);

                                }

                                    return Err(Error::<T>::ParaIdNotRegistered.into());

                    Ok(())

                })?;

                Self::schedule_parachain_cleanup(para_id)?;

                Self::deposit_event(Event::ParaIdDeregistered { para_id });

            Ok(())

        }

        fn do_mark_valid_for_collating(para_id: ParaId) -> DispatchResult {

            let is_pending_verification = PendingVerification::<T>::take(para_id).is_some();

            if !is_pending_verification {

                return Err(Error::<T>::ParaIdNotInPendingVerification.into());

            }

            Self::schedule_parachain_change(|para_ids| {

                // We don't want to add duplicate para ids, so we check whether the potential new

                // para id is already present in the list. Because the list is always ordered, we can

                // leverage the binary search which makes this check O(log n).

                match para_ids.binary_search(&para_id) {

                    Err(index) => {

                        para_ids

                            .try_insert(index, para_id)

                            .map_err(|_e| Error::<T>::ParaIdListFull)?;

                Ok(())

            })?;

            T::RegistrarHooks::check_valid_for_collating(para_id)?;

            Self::deposit_event(Event::ParaIdValidForCollating { para_id });

            T::RegistrarHooks::para_marked_valid_for_collating(para_id);

            Ok(())

        }

        pub fn relay_signature_msg(

            para_id: ParaId,

            tanssi_account: &T::AccountId,

            relay_storage_root: H256,

        ) -> Vec<u8> {

            (para_id, tanssi_account, relay_storage_root).encode()

        }

        fn schedule_parachain_change(

            updater: impl FnOnce(&mut BoundedVec<ParaId, T::MaxLengthParaIds>) -> DispatchResult,

        ) -> DispatchResult {

            let mut pending_paras = PendingParaIds::<T>::get();

            // First, we need to decide what we should use as the base paras.

            let mut base_paras = pending_paras

                .last()

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

                .unwrap_or_else(Self::registered_para_ids);

            updater(&mut base_paras)?;

            let new_paras = base_paras;

            let scheduled_session = Self::scheduled_session();

            if let Some(&mut (_, ref mut paras)) = pending_paras

                .iter_mut()

                .find(|&&mut (apply_at_session, _)| apply_at_session >= scheduled_session)

            {

                *paras = new_paras;

            } else {

                // We are scheduling a new parachains change for the scheduled session.

                pending_paras.push((scheduled_session, new_paras));

            }

            <PendingParaIds<T>>::put(pending_paras);

            Ok(())

        }

        fn schedule_paused_parachain_change(

            updater: impl FnOnce(

                &mut BoundedVec<ParaId, T::MaxLengthParaIds>,

                &mut BoundedVec<ParaId, T::MaxLengthParaIds>,

            ) -> DispatchResult,

        ) -> DispatchResult {

            let mut pending_paras = PendingParaIds::<T>::get();

            let mut pending_paused = PendingPaused::<T>::get();

            // First, we need to decide what we should use as the base paras.

            let mut base_paras = pending_paras

                .last()

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

                .unwrap_or_else(Self::registered_para_ids);

            let mut base_paused = pending_paused

                .last()

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

                .unwrap_or_else(Self::paused);

            let old_base_paras = base_paras.clone();

            let old_base_paused = base_paused.clone();

            updater(&mut base_paras, &mut base_paused)?;

            if base_paras != old_base_paras {

                let new_paras = base_paras;

                let scheduled_session = Self::scheduled_session();

                if let Some(&mut (_, ref mut paras)) = pending_paras

                    .iter_mut()

                    .find(|&&mut (apply_at_session, _)| apply_at_session >= scheduled_session)

                {

                    *paras = new_paras;

                } else {

                    // We are scheduling a new parachains change for the scheduled session.

                    pending_paras.push((scheduled_session, new_paras));

                }

                <PendingParaIds<T>>::put(pending_paras);

            }

            if base_paused != old_base_paused {

                let new_paused = base_paused;

                let scheduled_session = Self::scheduled_session();

                if let Some(&mut (_, ref mut paras)) = pending_paused

                    .iter_mut()

                    .find(|&&mut (apply_at_session, _)| apply_at_session >= scheduled_session)

                {

                    *paras = new_paused;

                } else {

                    // We are scheduling a new parachains change for the scheduled session.

                    pending_paused.push((scheduled_session, new_paused));

                }

                <PendingPaused<T>>::put(pending_paused);

            }

            Ok(())

        }

        fn schedule_parathread_params_change(

            para_id: ParaId,

            updater: impl FnOnce(&mut ParathreadParamsTy) -> DispatchResult,

        ) -> DispatchResult {

            let params = match ParathreadParams::<T>::get(para_id) {

                Some(x) => x,

                    return Err(Error::<T>::NotAParathread.into());

            let mut pending_params = PendingParathreadParams::<T>::get();

            // First, we need to decide what we should use as the base params.

            let mut base_params = pending_params

                .last()

                .and_then(|(_, para_id_params)| {

                })

                .unwrap_or(params);

            updater(&mut base_params)?;

            let new_params = base_params;

            let scheduled_session = Self::scheduled_session();

            if let Some(&mut (_, ref mut para_id_params)) = pending_params

                .iter_mut()

                .find(|&&mut (apply_at_session, _)| apply_at_session >= scheduled_session)

            } else {

                // We are scheduling a new parathread params change for the scheduled session.

                pending_params.push((

                    scheduled_session,

                    BoundedVec::truncate_from(vec![(para_id, new_params)]),

                ));

            }

            <PendingParathreadParams<T>>::put(pending_params);

            Ok(())

        }

        fn scheduled_session() -> T::SessionIndex {

            T::CurrentSessionIndex::session_index().saturating_add(T::SessionDelay::get())

        }

        pub fn initializer_on_new_session(

            session_index: &T::SessionIndex,

        ) -> SessionChangeOutcome<T> {

            let pending_paras = <PendingParaIds<T>>::get();

            let prev_paras = RegisteredParaIds::<T>::get();

            let new_paras = if !pending_paras.is_empty() {

                let (mut past_and_present, future) = pending_paras

                    .into_iter()

                    .partition::<Vec<_>, _>(|&(apply_at_session, _)| {

                        apply_at_session <= *session_index

                    });

                if past_and_present.len() > 1 {

                }

                let new_paras = past_and_present.pop().map(|(_, paras)| paras);

                if let Some(ref new_paras) = new_paras {

                    // Apply the new parachain list.

                    RegisteredParaIds::<T>::put(new_paras);

                    <PendingParaIds<T>>::put(future);

                }

                new_paras

                None

            let pending_paused = <PendingPaused<T>>::get();

            if !pending_paused.is_empty() {

                let (mut past_and_present, future) = pending_paused

                    .into_iter()

                    .partition::<Vec<_>, _>(|&(apply_at_session, _)| {

                        apply_at_session <= *session_index

                    });

                if past_and_present.len() > 1 {

                }

                let new_paused = past_and_present.pop().map(|(_, paras)| paras);

                if let Some(ref new_paused) = new_paused {

                    // Apply the new parachain list.

                    Paused::<T>::put(new_paused);

                    <PendingPaused<T>>::put(future);

                }

            }

            let pending_parathread_params = <PendingParathreadParams<T>>::get();

            if !pending_parathread_params.is_empty() {

                let (mut past_and_present, future) = pending_parathread_params

                    .into_iter()

                    .partition::<Vec<_>, _>(|&(apply_at_session, _)| {

                        apply_at_session <= *session_index

                    });

                if past_and_present.len() > 1 {

                }

                let new_params = past_and_present.pop().map(|(_, params)| params);

                if let Some(ref new_params) = new_params {

                    for (para_id, params) in new_params {

                        <ParathreadParams<T>>::insert(para_id, params);

                    }

                    <PendingParathreadParams<T>>::put(future);

                }

            }

            let pending_to_remove = <PendingToRemove<T>>::get();

            if !pending_to_remove.is_empty() {

                let (past_and_present, future) =

                    pending_to_remove.into_iter().partition::<Vec<_>, _>(

                        |&(apply_at_session, _)| apply_at_session <= *session_index,

                    );

                if !past_and_present.is_empty() {

                    let mut removed_para_ids = BTreeSet::new();

                    for (_, new_paras) in &past_and_present {

                        for para_id in new_paras {

                            Self::cleanup_deregistered_para_id(*para_id);

                            removed_para_ids.insert(*para_id);

                        }

                    let mut pending_parathread_params = <PendingParathreadParams<T>>::get();

                    for (_, new_params) in &mut pending_parathread_params {

                        new_params.retain(|(para_id, _params)| {

                            // Retain para ids that are not in the list of removed para ids

                            !removed_para_ids.contains(para_id)

                        });

                    }

                    <PendingParathreadParams<T>>::put(pending_parathread_params);

                    <PendingToRemove<T>>::put(future);

                }

            }

            SessionChangeOutcome {

                prev_paras,

                new_paras,

            }

        }

        fn cleanup_deregistered_para_id(para_id: ParaId) {

            ParaGenesisData::<T>::remove(para_id);

            ParathreadParams::<T>::remove(para_id);

            if let Some(asset_info) = RegistrarDeposit::<T>::take(para_id) {

                // Release hold

                let _ = T::Currency::release(

                    &HoldReason::RegistrarDeposit.into(),

                    &asset_info.creator,

                    asset_info.deposit,

                    Precision::Exact,

                );

            }

            ParaManager::<T>::remove(para_id);

            T::RegistrarHooks::para_deregistered(para_id);

        }

        fn schedule_parachain_cleanup(para_id: ParaId) -> DispatchResult {

            let scheduled_session = Self::scheduled_session();

            let mut pending_paras = PendingToRemove::<T>::get();

            let base_paras = match pending_paras

                .binary_search_by_key(&scheduled_session, |(session, _paras)| *session)

                Ok(i) => &mut pending_paras[i].1,

                Err(i) => {

                    pending_paras.insert(i, (scheduled_session, Default::default()));

                    &mut pending_paras[i].1

            match base_paras.binary_search(&para_id) {

                Err(index) => {

                    base_paras

                        .try_insert(index, para_id)

                        .map_err(|_e| Error::<T>::ParaIdListFull)?;

            <PendingToRemove<T>>::put(pending_paras);

            Ok(())

        }

        pub fn registered_para_ids() -> BoundedVec<ParaId, T::MaxLengthParaIds> {

            RegisteredParaIds::<T>::get()

        }

        pub fn pending_registered_para_ids(

        ) -> Vec<(T::SessionIndex, BoundedVec<ParaId, T::MaxLengthParaIds>)> {

            PendingParaIds::<T>::get()

        }

        pub fn para_genesis_data(

            para_id: ParaId,

        ) -> Option<ContainerChainGenesisData<T::MaxLengthTokenSymbol>> {

            ParaGenesisData::<T>::get(para_id)

        }

        pub fn paused() -> BoundedVec<ParaId, T::MaxLengthParaIds> {

            Paused::<T>::get()

        }

        pub fn parathread_params(para_id: ParaId) -> Option<ParathreadParamsTy> {

            ParathreadParams::<T>::get(para_id)

        }

        pub fn registrar_deposit(para_id: ParaId) -> Option<DepositInfo<T>> {

            RegistrarDeposit::<T>::get(para_id)

        }

        fn current_container_chains() -> BoundedVec<ParaId, Self::MaxContainerChains> {

            Self::registered_para_ids()

        }

        fn session_container_chains(session_index: T::SessionIndex) -> SessionContainerChains {

            let (past_and_present, _) = Pallet::<T>::pending_registered_para_ids()

                .into_iter()

                .partition::<Vec<_>, _>(|&(apply_at_session, _)| apply_at_session <= session_index);

            let paras = if let Some(last) = past_and_present.last() {

                last.1.clone()

                Pallet::<T>::registered_para_ids()

            let mut parachains = vec![];

            let mut parathreads = vec![];

            for para_id in paras {

                if let Some(parathread_params) = ParathreadParams::<T>::get(para_id) {

                    parathreads.push((para_id, parathread_params));

                } else {

                    parachains.push(para_id);

                }

            SessionContainerChains {

                parachains,

                parathreads,

            }

        }