#[frame_support::pallet]

    #[pallet::pallet]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::genesis_build]

        fn build(&self) {

            let duplicate_validators = self

                .whitelisted_validators

                .iter()

                // T::ValidatorId does not impl Ord or Hash so we cannot collect into set directly,

                // but we can check for duplicates if we encode them first.

                .map(|x| x.encode())

                .collect::<sp_std::collections::btree_set::BTreeSet<_>>();

            assert!(

                duplicate_validators.len() == self.whitelisted_validators.len(),

            let bounded_validators = BoundedVec::<_, T::MaxWhitelistedValidators>::try_from(

                self.whitelisted_validators.clone(),

            )

            .expect("genesis validators are more than T::MaxWhitelistedValidators");

            <WhitelistedValidators<T>>::put(bounded_validators);

            <SkipExternalValidators<T>>::put(self.skip_external_validators);

        }

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

        /// A new whitelisted validator was added.

        /// A whitelisted validator was removed.

    #[pallet::error]

        pub fn skip_external_validators(origin: OriginFor<T>, skip: bool) -> DispatchResult {

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

            <SkipExternalValidators<T>>::put(skip);

            Ok(())

        ) -> DispatchResultWithPostInfo {

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

            let maybe_validator_id = T::ValidatorIdOf::convert(who.clone())

                .filter(T::ValidatorRegistration::is_registered);

            let validator_id = maybe_validator_id.ok_or(Error::<T>::NoKeysRegistered)?;

            <WhitelistedValidators<T>>::try_mutate(|whitelisted| -> DispatchResult {

                if whitelisted.contains(&validator_id) {

                    Err(Error::<T>::AlreadyWhitelisted)?;

                }

                whitelisted

                    .try_push(validator_id.clone())

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

                Ok(())

            })?;

            Self::deposit_event(Event::WhitelistedValidatorAdded { account_id: who });

            let weight_used = <T as Config>::WeightInfo::add_whitelisted(

                WhitelistedValidators::<T>::decode_len()

                    .unwrap_or_default()

                    .try_into()

                    .unwrap_or(T::MaxWhitelistedValidators::get().saturating_sub(1)),

            );

            Ok(Some(weight_used).into())

        pub fn remove_whitelisted(origin: OriginFor<T>, who: T::AccountId) -> DispatchResult {

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

            let validator_id = T::ValidatorIdOf::convert(who.clone())

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

            <WhitelistedValidators<T>>::try_mutate(|whitelisted| -> DispatchResult {

                let pos = whitelisted

                    .iter()

                    .position(|x| x == &validator_id)

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

                whitelisted.remove(pos);

                Ok(())

            })?;

            Self::deposit_event(Event::WhitelistedValidatorRemoved { account_id: who });

            Ok(())

        pub fn force_era(origin: OriginFor<T>, mode: Forcing) -> DispatchResult {

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

            Self::set_force_era(mode);

            Ok(())

        pub fn set_external_validators(validators: Vec<T::ValidatorId>) -> DispatchResult {

            // If more validators than max, take the first n

            let validators = BoundedVec::truncate_from(validators);

            <ExternalValidators<T>>::put(validators);

            Ok(())

        }

        pub(crate) fn set_force_era(mode: Forcing) {

            log::info!("Setting force era mode {:?}.", mode);

            ForceEra::<T>::put(mode);

            Self::deposit_event(Event::<T>::ForceEra { mode });

        }

        pub fn whitelisted_validators() -> Vec<T::ValidatorId> {

            <WhitelistedValidators<T>>::get().into()

        }

        pub fn active_era() -> Option<ActiveEraInfo> {

            <ActiveEra<T>>::get()

        }

        pub fn current_era() -> Option<EraIndex> {

            <CurrentEra<T>>::get()

        }

        pub fn eras_start_session_index(era: EraIndex) -> Option<u32> {

            <ErasStartSessionIndex<T>>::get(era)

        }

        pub fn validators() -> Vec<T::ValidatorId> {

            let mut validators: Vec<_> = WhitelistedValidators::<T>::get().into();

            if !SkipExternalValidators::<T>::get() {

                validators.extend(ExternalValidators::<T>::get())

            }

            remove_duplicates(validators)

        }

        pub(crate) fn new_session(session_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {

            if let Some(current_era) = Self::current_era() {

                let current_era_start_session_index = Self::eras_start_session_index(current_era)

                    .unwrap_or_else(|| {

                    });

                let era_length = session_index.saturating_sub(current_era_start_session_index); // Must never happen.

                match ForceEra::<T>::get() {

                    Forcing::ForceNew => (),

                    Forcing::ForceAlways => (),

                    Forcing::NotForcing if era_length >= T::SessionsPerEra::get() => (),

                        return None;

                let maybe_new_era_validators = Self::try_trigger_new_era(session_index);

                if maybe_new_era_validators.is_some()

                    && matches!(ForceEra::<T>::get(), Forcing::ForceNew)

                {

                    Self::set_force_era(Forcing::NotForcing);

                }

                maybe_new_era_validators

                log!(log::Level::Debug, "Starting the first era.");

                Self::try_trigger_new_era(session_index)

        }

        pub(crate) fn start_session(start_session: SessionIndex) {

            let next_active_era = Self::active_era().map(|e| e.index + 1).unwrap_or(0);

            if let Some(next_active_era_start_session_index) =

                Self::eras_start_session_index(next_active_era)

                if next_active_era_start_session_index == start_session {

                    Self::start_era(start_session);

                } else if next_active_era_start_session_index < start_session {

            }

        }

        pub(crate) fn end_session(session_index: SessionIndex) {

            if let Some(active_era) = Self::active_era() {

                if let Some(next_active_era_start_session_index) =

                    Self::eras_start_session_index(active_era.index + 1)

                    if next_active_era_start_session_index == session_index + 1 {

                        Self::end_era(active_era, session_index);

                    }

                }

        }

        pub(crate) fn start_era(start_session: SessionIndex) {

            let active_era = ActiveEra::<T>::mutate(|active_era| {

                let new_index = active_era.as_ref().map(|info| info.index + 1).unwrap_or(0);

                *active_era = Some(ActiveEraInfo {

                    index: new_index,

                    // Set new active era start in next `on_finalize`. To guarantee usage of `Time`

                    start: None,

                });

                new_index

            });

            Self::deposit_event(Event::NewEra { era: active_era });

            T::OnEraStart::on_era_start(active_era, start_session);

        }

        pub(crate) fn end_era(active_era: ActiveEraInfo, _session_index: SessionIndex) {

            // Note: active_era.start can be None if end era is called during genesis config.

            T::OnEraEnd::on_era_end(active_era.index);

        }

        pub fn trigger_new_era(start_session_index: SessionIndex) -> Vec<T::ValidatorId> {

            // Increment or set current era.

            let new_planned_era = CurrentEra::<T>::mutate(|s| {

                *s = Some(s.map(|s| s + 1).unwrap_or(0));

                s.unwrap()

            });

            ErasStartSessionIndex::<T>::insert(&new_planned_era, &start_session_index);

            if let Some(old_era) = new_planned_era.checked_sub(T::HistoryDepth::get() + 1) {

            }

            Self::validators()

        }

        pub(crate) fn try_trigger_new_era(

            start_session_index: SessionIndex,

        ) -> Option<Vec<T::ValidatorId>> {

            Some(Self::trigger_new_era(start_session_index))

        }

    #[pallet::hooks]

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

            // just return the weight of the on_finalize.

            T::DbWeight::get().reads(1)

        }

        fn on_finalize(_n: BlockNumberFor<T>) {

            if let Some(mut active_era) = <ActiveEra<T>>::get() {

                if active_era.start.is_none() {

                    let now_as_millis_u64 = T::UnixTime::now().as_millis().saturated_into::<u64>();

                    active_era.start = Some(now_as_millis_u64);

                    // This write only ever happens once, we don't include it in the weight in

                    // general

                    ActiveEra::<T>::put(active_era);

                }

        }

fn remove_duplicates<T: Ord + Clone>(input: Vec<T>) -> Vec<T> {

    let mut seen = BTreeSet::new();

    let mut result = Vec::with_capacity(input.len());

    for item in input {

        if seen.insert(item.clone()) {

            result.push(item);

        }

    result

}

    fn new_session(new_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {

        log!(log::Level::Trace, "planning new session {}", new_index);

        Self::new_session(new_index)

    }

    fn new_session_genesis(new_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {

        log!(

            log::Level::Trace,

        Self::new_session(new_index)

    }

    fn start_session(start_index: SessionIndex) {

        log!(log::Level::Trace, "starting session {}", start_index);

        Self::start_session(start_index)

    }

    fn end_session(end_index: SessionIndex) {

        log!(log::Level::Trace, "ending session {}", end_index);

        Self::end_session(end_index)

    }

    fn new_session(new_index: SessionIndex) -> Option<Vec<(T::ValidatorId, ())>> {

        <Self as pallet_session::SessionManager<_>>::new_session(new_index)

            .map(|r| r.into_iter().map(|v| (v, Default::default())).collect())

    }

    fn start_session(start_index: SessionIndex) {

        <Self as pallet_session::SessionManager<_>>::start_session(start_index)

    }

    fn end_session(end_index: SessionIndex) {

        <Self as pallet_session::SessionManager<_>>::end_session(end_index)

    }

    fn active_era() -> ActiveEraInfo {

        <ActiveEra<T>>::get().unwrap_or(ActiveEraInfo {

            index: 0,

            start: None,

        })

    }

    fn era_to_session_start(era_index: EraIndex) -> Option<u32> {

        <ErasStartSessionIndex<T>>::get(era_index)

    }

    fn validators() -> Vec<T::ValidatorId> {

        Self::validators()

    }

    fn invulnerables() -> Vec<T::ValidatorId> {

        Self::whitelisted_validators()

    }

    /// Not forcing anything - just let whatever happen.

    /// Force a new era on the next session start, then reset to `NotForcing` as soon as it is done.

    /// Avoid a new era indefinitely.

    /// Force a new era at the end of all sessions indefinitely.