// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Tanssi is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

//! # Registrar Pallet

//!

//! This pallet is in charge of registering containerChains (identified by their Id)

//! that have to be served by the orchestrator chain. Parachains registrations and de-

//! registrations are not immediately applied, but rather they take T::SessionDelay sessions

//! to be applied.

//!

//! Registered container chains are stored in the PendingParaIds storage item until the session

//! in which they can be onboarded arrives, in which case they are added to the RegisteredParaIds

//! storage item.

#![cfg_attr(not(feature = "std"), no_std)]

extern crate alloc;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

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

mod benchmark_blob;

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

mod benchmarks;

pub mod weights;

pub use weights::WeightInfo;

pub use pallet::*;

use {

    alloc::{collections::btree_set::BTreeSet, vec, vec::Vec},

    cumulus_primitives_core::relay_chain::HeadData,

    dp_chain_state_snapshot::GenericStateProof,

    dp_container_chain_genesis_data::ContainerChainGenesisData,

    dp_core::{well_known_keys::REGISTRAR_PARAS_INDEX, ParaInfo},

    frame_support::{

        pallet_prelude::*,

        traits::{

            fungible::{Inspect, InspectHold, Mutate, MutateHold},

            tokens::{Fortitude, Precision, Restriction},

            EnsureOriginWithArg,

        },

        DefaultNoBound, Hashable, LOG_TARGET,

    },

    frame_system::pallet_prelude::*,

    parity_scale_codec::{Decode, Encode},

    sp_core::H256,

    sp_runtime::{

        traits::{AtLeast32BitUnsigned, Verify},

        Saturating,

    },

    tp_traits::{

        GetCurrentContainerChains, GetSessionContainerChains, GetSessionIndex, ParaId,

        ParathreadParams as ParathreadParamsTy, RegistrarHandler, RelayStorageRootProvider,

        SessionContainerChains, SlotFrequency,

    },

};

#[frame_support::pallet]

pub mod pallet {

    use super::*;

    #[pallet::pallet]

    pub struct Pallet<T>(_);

    #[pallet::genesis_config]

    #[derive(DefaultNoBound)]

    pub struct GenesisConfig<T: Config> {

        /// Para ids

        pub para_ids: Vec<(

            ParaId,

            ContainerChainGenesisData,

            Option<ParathreadParamsTy>,

        )>,

        #[serde(skip)]

        pub phantom: PhantomData<T>,

    }

    #[pallet::genesis_build]

    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

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

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

                } else {

                }

                        genesis_data_size,

                    );

                if let Some(parathread_params) = parathread_params {

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

                }

            }

    }

    /// Configure the pallet by specifying the parameters and types on which it depends.

    #[pallet::config]

    pub trait Config: frame_system::Config {

        /// Origin that is allowed to call maintenance extrinsics for container owner

        type RegistrarOrigin: EnsureOriginWithArg<Self::RuntimeOrigin, ParaId>;

        /// Origin that is allowed to call mark_valid_for_collating

        type MarkValidForCollatingOrigin: EnsureOrigin<Self::RuntimeOrigin>;

        /// Max length of para id list

        #[pallet::constant]

        type MaxLengthParaIds: Get<u32>;

        /// Max length of encoded genesis data

        #[pallet::constant]

        type MaxGenesisDataSize: Get<u32>;

        type RegisterWithRelayProofOrigin: EnsureOrigin<

            Self::RuntimeOrigin,

            Success = Self::AccountId,

        >;

        type RelayStorageRootProvider: RelayStorageRootProvider;

        type SessionIndex: parity_scale_codec::FullCodec + TypeInfo + Copy + AtLeast32BitUnsigned;

        #[pallet::constant]

        type SessionDelay: Get<Self::SessionIndex>;

        type CurrentSessionIndex: GetSessionIndex<Self::SessionIndex>;

        type Currency: Mutate<Self::AccountId>

            + MutateHold<Self::AccountId, Reason = Self::RuntimeHoldReason>;

        type RuntimeHoldReason: From<HoldReason>;

        type RegistrarHooks: RegistrarHooks;

        /// External manager that takes care of executing specific operations

        /// when register-like functions of this pallet are called.

        ///

        /// Mostly used when we are in a relay-chain configuration context (Dancelight)

        /// to also register, deregister and upgrading paraIds in polkadot's

        /// paras_registrar pallet.

        type InnerRegistrar: RegistrarHandler<Self::AccountId>;

        type WeightInfo: WeightInfo;

        #[pallet::constant]

        type DataDepositPerByte: Get<<Self::Currency as Inspect<Self::AccountId>>::Balance>;

    }

    #[pallet::storage]

    pub type RegisteredParaIds<T: Config> =

        StorageValue<_, BoundedVec<ParaId, T::MaxLengthParaIds>, ValueQuery>;

    #[pallet::storage]

    #[pallet::unbounded]

    pub type PendingParaIds<T: Config> = StorageValue<

        _,

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

        ValueQuery,

    >;

    #[pallet::storage]

    // TODO: this is not unbounded because we check the encoded size in register

    #[pallet::unbounded]

    pub type ParaGenesisData<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, ContainerChainGenesisData, OptionQuery>;

    #[pallet::storage]

    pub type PendingVerification<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, (), OptionQuery>;

    #[pallet::storage]

    pub type Paused<T: Config> =

        StorageValue<_, BoundedVec<ParaId, T::MaxLengthParaIds>, ValueQuery>;

    #[pallet::storage]

    #[pallet::unbounded]

    pub type PendingPaused<T: Config> = StorageValue<

        _,

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

        ValueQuery,

    >;

    #[pallet::storage]

    #[pallet::unbounded]

    pub type PendingToRemove<T: Config> = StorageValue<

        _,

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

        ValueQuery,

    >;

    #[pallet::storage]

    pub type ParathreadParams<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, ParathreadParamsTy, OptionQuery>;

    #[pallet::storage]

    #[pallet::unbounded]

    pub type PendingParathreadParams<T: Config> = StorageValue<

        _,

        Vec<(

            T::SessionIndex,

            BoundedVec<(ParaId, ParathreadParamsTy), T::MaxLengthParaIds>,

        )>,

        ValueQuery,

    >;

    /// This storage aims to act as a 'buffer' for paraIds that must be deregistered at the

    /// end of the block execution by calling 'T::InnerRegistrar::deregister()' implementation.

    ///

    /// We need this buffer because when we are using this pallet on a relay-chain environment

    /// like Dancelight (where 'T::InnerRegistrar' implementation is usually the

    /// 'paras_registrar' pallet) we need to deregister (via 'paras_registrar::deregister')

    /// the same paraIds we have in 'PendingToRemove<T>', and we need to do this deregistration

    /// process inside 'on_finalize' hook.

    ///

    /// It can be the case that some paraIds need to be downgraded to a parathread before

    /// deregistering on 'paras_registrar'. This process usually takes 2 sessions,

    /// and the actual downgrade happens when the block finalizes.

    ///

    /// Therefore, if we tried to perform this relay deregistration process at the beginning

    /// of the session/block inside ('on_initialize') initializer_on_new_session() as we do

    /// for this pallet, it would fail due to the downgrade process could have not taken

    /// place yet.

    #[pallet::storage]

    pub type BufferedParasToDeregister<T: Config> =

        StorageValue<_, BoundedVec<ParaId, T::MaxLengthParaIds>, ValueQuery>;

    pub type DepositBalanceOf<T> =

        <<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;

    #[derive(

        Default, Clone, Encode, Decode, RuntimeDebug, PartialEq, scale_info::TypeInfo, MaxEncodedLen,

    )]

    #[scale_info(skip_type_params(T))]

    pub struct DepositInfo<T: Config> {

        pub creator: T::AccountId,

        pub deposit: DepositBalanceOf<T>,

    }

    /// Registrar deposits, a mapping from paraId to a struct

    /// holding the creator (from which the deposit was reserved) and

    /// the deposit amount

    #[pallet::storage]

    pub type RegistrarDeposit<T: Config> = StorageMap<_, Blake2_128Concat, ParaId, DepositInfo<T>>;

    #[pallet::storage]

    pub type ParaManager<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, T::AccountId, OptionQuery>;

    #[pallet::event]

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

    pub enum Event<T: Config> {

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

        ParaIdRegistered {

            para_id: ParaId,

        },

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

        ParaIdDeregistered {

            para_id: ParaId,

        },

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

        ParaIdValidForCollating {

            para_id: ParaId,

        },

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

        ParaIdPaused {

            para_id: ParaId,

        },

        /// A para id has been unpaused.

        ParaIdUnpaused {

            para_id: ParaId,

        },

        /// Parathread params changed

        ParathreadParamsChanged {

            para_id: ParaId,

        },

        /// Para manager has changed

        ParaManagerChanged {

            para_id: ParaId,

            manager_address: T::AccountId,

        },

        // Deposit has updated

        DepositUpdated {

            para_id: ParaId,

        },

    }

    #[pallet::error]

    pub enum Error<T> {

        /// Attempted to register a ParaId that was already registered

        ParaIdAlreadyRegistered,

        /// Attempted to deregister a ParaId that is not registered

        ParaIdNotRegistered,

        /// Attempted to deregister a ParaId that is already being deregistered

        ParaIdAlreadyDeregistered,

        /// Attempted to pause a ParaId that was already paused

        ParaIdAlreadyPaused,

        /// Attempted to unpause a ParaId that was not paused

        ParaIdNotPaused,

        /// The bounded list of ParaIds has reached its limit

        ParaIdListFull,

        /// Attempted to register a ParaId with a genesis data size greater than the limit

        GenesisDataTooBig,

        /// Tried to mark_valid_for_collating a ParaId that is not in PendingVerification

        ParaIdNotInPendingVerification,

        /// Tried to register a ParaId with an account that did not have enough balance for the deposit

        NotSufficientDeposit,

        /// Tried to change parathread params for a para id that is not a registered parathread

        NotAParathread,

        /// Attempted to execute an extrinsic meant only for the para creator

        NotParaCreator,

        /// The relay storage root for the corresponding block number could not be retrieved

        RelayStorageRootNotFound,

        /// The provided relay storage proof is not valid

        InvalidRelayStorageProof,

        /// The provided signature from the parachain manager in the relay is not valid

        InvalidRelayManagerSignature,

        /// Tried to deregister a parachain that was not deregistered from the relay chain

        ParaStillExistsInRelay,

        /// Tried to register a paraId in a relay context without specifying a proper HeadData.

        HeadDataNecessary,

        /// Tried to register a paraId in a relay context without specifying a wasm chain code.

        WasmCodeNecessary,

    }

    #[pallet::composite_enum]

    pub enum HoldReason {

        RegistrarDeposit,

    }

    #[pallet::hooks]

    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

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

        fn try_state(_n: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {

            use {alloc::collections::btree_set::BTreeSet, scale_info::prelude::format};

            // A para id can only be in 1 of [`RegisteredParaIds`, `PendingVerification`, `Paused`]

            // Get all those para ids and check for duplicates

            let mut para_ids: Vec<ParaId> = vec![];

            para_ids.extend(RegisteredParaIds::<T>::get());

            para_ids.extend(PendingVerification::<T>::iter_keys());

            para_ids.extend(Paused::<T>::get());

            para_ids.sort();

            para_ids.dedup_by(|a, b| {

                if a == b {

                    panic!("Duplicate para id: {}", u32::from(*a));

                } else {

                    false

                }

            });

            // All para ids have an entry in `ParaGenesisData`

            for para_id in &para_ids {

                assert!(

                    ParaGenesisData::<T>::contains_key(para_id),

                    "Para id {} missing genesis data",

                    u32::from(*para_id)

                );

            }

            // All entries in `RegistrarDeposit` and `ParaGenesisData` are in one of the other lists

            let mut para_id_set = BTreeSet::from_iter(para_ids.iter().cloned());

            // Also add the Pending lists here

            para_id_set.extend(

                PendingParaIds::<T>::get()

                    .into_iter()

                    .flat_map(|(_session_index, x)| x),

            );

            para_id_set.extend(

                PendingPaused::<T>::get()

                    .into_iter()

                    .flat_map(|(_session_index, x)| x),

            );

            para_id_set.extend(

                PendingToRemove::<T>::get()

                    .into_iter()

                    .flat_map(|(_session_index, x)| x),

            );

            let entries: Vec<_> = RegistrarDeposit::<T>::iter().map(|(k, _v)| k).collect();

            for para_id in entries {

                assert!(

                    para_id_set.contains(&para_id),

                    "Found RegistrarDeposit for unknown para id: {}",

                    u32::from(para_id)

                );

            }

            let entries: Vec<_> = ParaGenesisData::<T>::iter().map(|(k, _v)| k).collect();

            for para_id in entries {

                assert!(

                    para_id_set.contains(&para_id),

                    "Found ParaGenesisData for unknown para id: {}",

                    u32::from(para_id)

                );

            }

            // Sorted storage items are sorted

            fn assert_is_sorted_and_unique<T: Ord>(x: &[T], name: &str) {

                assert!(

                    x.windows(2).all(|w| w[0] < w[1]),

                    "sorted list not sorted or not unique: {}",

                    name,

                );

            }

            assert_is_sorted_and_unique(&RegisteredParaIds::<T>::get(), "RegisteredParaIds");

            assert_is_sorted_and_unique(&Paused::<T>::get(), "Paused");

            for (i, (_session_index, x)) in PendingParaIds::<T>::get().into_iter().enumerate() {

                assert_is_sorted_and_unique(&x, &format!("PendingParaIds[{}]", i));

            }

            for (i, (_session_index, x)) in PendingPaused::<T>::get().into_iter().enumerate() {

                assert_is_sorted_and_unique(&x, &format!("PendingPaused[{}]", i));

            }

            for (i, (_session_index, x)) in PendingToRemove::<T>::get().into_iter().enumerate() {

                assert_is_sorted_and_unique(&x, &format!("PendingToRemove[{}]", i));

            }

            // Pending storage items are sorted and session index is unique

            let pending: Vec<_> = PendingParaIds::<T>::get()

                .into_iter()

                .map(|(session_index, _x)| session_index)

                .collect();

            assert_is_sorted_and_unique(&pending, "PendingParaIds");

            let pending: Vec<_> = PendingPaused::<T>::get()

                .into_iter()

                .map(|(session_index, _x)| session_index)

                .collect();

            assert_is_sorted_and_unique(&pending, "PendingPaused");

            let pending: Vec<_> = PendingToRemove::<T>::get()

                .into_iter()

                .map(|(session_index, _x)| session_index)

                .collect();

            assert_is_sorted_and_unique(&pending, "PendingToRemove");

            Ok(())

        }

    }

    #[pallet::call]

    impl<T: Config> Pallet<T> {

        /// Register container-chain

        #[pallet::call_index(0)]

        #[pallet::weight(T::WeightInfo::register(genesis_data.encoded_size() as u32, genesis_data.storage.len() as u32))]

        pub fn register(

            origin: OriginFor<T>,

            para_id: ParaId,

            genesis_data: ContainerChainGenesisData,

            head_data: Option<HeadData>,

        }

        /// Deregister container-chain.

        ///

        /// If a container-chain is registered but not marked as valid_for_collating, this will remove it

        /// from `PendingVerification` as well.

        #[pallet::call_index(1)]

        #[pallet::weight(T::WeightInfo::deregister_immediate(

        ).max(T::WeightInfo::deregister_scheduled(

        )))]

        }

        /// Mark container-chain valid for collating

        #[pallet::call_index(2)]

        #[pallet::weight(T::WeightInfo::mark_valid_for_collating())]

        }

        /// Pause container-chain from collating. Does not remove its boot nodes nor its genesis config.

        /// Only container-chains that have been marked as valid_for_collating can be paused.

        #[pallet::call_index(4)]

        #[pallet::weight(T::WeightInfo::pause_container_chain())]

                    }

                }

                    // We can only pause para ids that are marked as valid,

                    // otherwise unpausing them later would cause problems

                }

        }

        /// Unpause container-chain.

        /// Only container-chains that have been paused can be unpaused.

        #[pallet::call_index(5)]

        #[pallet::weight(T::WeightInfo::unpause_container_chain())]

                }

                    // This Ok is unreachable, a para id cannot be in "RegisteredParaIds" and "Paused" at the same time

                    }

                }

        }

        /// Register parathread

        #[pallet::call_index(6)]

        #[pallet::weight(T::WeightInfo::register_parathread(genesis_data.encoded_size() as u32, genesis_data.storage.len() as u32))]

        pub fn register_parathread(

            origin: OriginFor<T>,

            para_id: ParaId,

            slot_frequency: SlotFrequency,

            genesis_data: ContainerChainGenesisData,

            head_data: Option<HeadData>,

            // Insert parathread params

        }

        /// Change parathread params

        #[pallet::call_index(7)]

        #[pallet::weight(T::WeightInfo::set_parathread_params())]

        pub fn set_parathread_params(

            origin: OriginFor<T>,

            para_id: ParaId,

            slot_frequency: SlotFrequency,

        }

        #[pallet::call_index(8)]

        #[pallet::weight(T::WeightInfo::set_para_manager())]

        pub fn set_para_manager(

            origin: OriginFor<T>,

            para_id: ParaId,

            manager_address: T::AccountId,

            // Allow root to force set para manager.

        }

        /// Register parachain or parathread

        #[pallet::call_index(9)]

        #[pallet::weight(T::WeightInfo::register_with_relay_proof(genesis_data.encoded_size() as u32, genesis_data.storage.len() as u32))]

        pub fn register_with_relay_proof(

            origin: OriginFor<T>,

            para_id: ParaId,

            parathread_params: Option<ParathreadParamsTy>,

            relay_proof_block_number: u32,

            relay_storage_proof: sp_trie::StorageProof,

            manager_signature: cumulus_primitives_core::relay_chain::Signature,

            genesis_data: ContainerChainGenesisData,

            head_data: Option<HeadData>,

                )

                    cumulus_primitives_core::relay_chain::AccountId,

                    cumulus_primitives_core::relay_chain::Balance,

            // Verify manager signature

            // Insert parathread params

        }

        /// Deregister a parachain that no longer exists in the relay chain. The origin of this

        /// extrinsic will be rewarded with the parachain deposit.

        #[pallet::call_index(10)]

        #[pallet::weight(T::WeightInfo::deregister_with_relay_proof_immediate(

        ).max(T::WeightInfo::deregister_with_relay_proof_scheduled(

        )))]

        pub fn deregister_with_relay_proof(

            origin: OriginFor<T>,

            para_id: ParaId,

            relay_proof_block_number: u32,

            relay_storage_proof: sp_trie::StorageProof,

                )

            // TODO: we don't even need to decode the value, only check if it exists

            // Need to add exists_storage method to dancekit

                    cumulus_primitives_core::relay_chain::AccountId,

                    cumulus_primitives_core::relay_chain::Balance,

            // Take the deposit immediately and give it to origin account

        }

        /// Recalculate and reconcile the reserved deposit for `para_id`.

        ///

        /// If the required amount differs from the currently held deposit,

        /// this extrinsic increases or releases the difference on the creator's account.

        #[pallet::call_index(11)]

        #[pallet::weight(T::WeightInfo::poke_deposit())]

            // Mutate the deposit entry in-place

                // Only the original creator of the para can poke their deposit.

                // Retrieve the genesis data and calculate the cost based on its encoded size.

                // If the current deposit already matches the required one, do nothing.

                // Adjust the held amount depending on whether we need to increase or decrease

                    // The deposit must increase

                    // Attempt to hold the additional amount from the creator's balance.

                } else {

                    // The deposit must decrease

                    // Release the exact delta from the hold.

                }

                // Update the stored deposit value

        }

    }

    pub struct SessionChangeOutcome<T: Config> {

        /// Previously active parachains.

        pub prev_paras: BoundedVec<ParaId, T::MaxLengthParaIds>,

        /// If new parachains have been applied in the new session, this is the new  list.

        pub new_paras: Option<BoundedVec<ParaId, T::MaxLengthParaIds>>,

    }

    impl<T: Config> Pallet<T> {

            // This check will only pass if both are true:

            // * The para_id has a deposit in pallet_registrar

            // * The signed_account is the para manager (or creator if None)

            } else {

            }

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

        pub fn benchmarks_get_or_create_para_manager(para_id: &ParaId) -> T::AccountId {

            use {

                frame_benchmarking::account,

                frame_support::{assert_ok, dispatch::RawOrigin},

            };

            let mut storage = BoundedVec::try_from(vec![]).unwrap();

            storage

                .try_push((b":code".to_vec(), vec![1; 10]).into())

                .unwrap();

            let genesis_data = ContainerChainGenesisData {

                storage,

                name: Default::default(),

                id: Default::default(),

                fork_id: Default::default(),

                extensions: Default::default(),

                properties: Default::default(),

            };

            // Return container chain manager, or register container chain as ALICE if it does not exist

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

                // Register as a new user

                /// Create a funded user.

                /// Used for generating the necessary amount for registering

                fn create_funded_user<T: Config>(

                    string: &'static str,

                    n: u32,

                    total: DepositBalanceOf<T>,

                ) -> (T::AccountId, DepositBalanceOf<T>) {

                    const SEED: u32 = 0;

                    let user = account(string, n, SEED);

                    assert_ok!(T::Currency::mint_into(&user, total));

                    (user, total)

                }

                let deposit = Self::get_genesis_cost(genesis_data.encoded_size());

                let new_balance = T::Currency::minimum_balance()

                    .saturating_mul(100_000_000u32.into())

                    .saturating_add(deposit);

                let account = create_funded_user::<T>("caller", 1000, new_balance).0;

                T::InnerRegistrar::prepare_chain_registration(*para_id, account.clone());

                let origin = RawOrigin::Signed(account);

                assert_ok!(Self::register(

                    origin.into(),

                    *para_id,

                    genesis_data.clone(),

                    T::InnerRegistrar::bench_head_data(),

                ));

            }

            let deposit_info = RegistrarDeposit::<T>::get(para_id).expect("Cannot return signed origin for a container chain that was registered by root. Try using a different para id");

            let deposit = Self::get_genesis_cost(genesis_data.encoded_size());

            // Fund deposit creator, just in case it is not a new account

            let new_balance = (T::Currency::minimum_balance().saturating_add(deposit))

                .saturating_mul(2u32.into());

            assert_ok!(T::Currency::mint_into(&deposit_info.creator, new_balance));

            deposit_info.creator

        }

            // 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.

            // Verify we can hold

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

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

            // Insert para id into PendingVerification

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

            // Register the paraId also in the relay context (if any).

            // Update DepositInfo

            );

            // 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.

                // Cleanup immediately

            } else {

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

                        Err(_) => {

                            // If the para id is not registered, it may be paused. In that case, remove it from there

                                Err(_) => {

                                }

                            }

                        }

                    }

                // Mark this para id for cleanup later

                // If we have InnerRegistrar set to a relay context (like Dancelight),

                // we first need to downgrade the paraId (if it was a parachain before)

                // and convert it to a parathread before deregistering it. Otherwise

                // the deregistration process will fail in the scheduled session.

                //

                // We only downgrade if the paraId is a parachain in the context of

                // this pallet.

            }

                // 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).

                    // This Ok is unreachable

                    }

                }

            // If we execute mark_valid_for_collating, we automatically upgrade

            // the paraId to a parachain (in the relay context) at the end of the execution.

            //

            // We only upgrade if the paraId is a parachain in the context of

            // this pallet.

        /// Relay parachain manager signature message. Includes:

        /// * para_id, in case the manager has more than 1 para in the relay

        /// * accountid in tanssi, to ensure that the creator role is assigned to the desired account

        /// * relay_storage_root, to make the signature network-specific, and also make it expire

        ///     when the relay storage root expires.

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

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

            // Check that the para id is a parathread by reading the old params

                None => {

                }

            };

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

                    {

                        }

                    }

            {

                    }

                }

        /// Return the session index that should be used for any future scheduled changes.

        /// Called by the initializer to note that a new session has started.

        ///

        /// Returns the parachain list that was actual before the session change and the parachain list

        /// that became active after the session change. If there were no scheduled changes, both will

        /// be the same.

                    // This should never happen since we schedule parachain changes only into the future

                    // sessions and this handler called for each session change.

                    );

            } else {

                // pending_paras.is_empty, so parachain list did not change

            };

                    // This should never happen since we schedule parachain changes only into the future

                    // sessions and this handler called for each session change.

                    );

                    // This should never happen since we schedule parachain changes only into the future

                    // sessions and this handler called for each session change.

                    );