// Copyright 2019-2025 PureStake Inc.

// This file is part of Moonbeam.

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

// Moonbeam 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 Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

//! # Parachain Staking

//! Minimal staking pallet that implements collator selection by total backed stake.

//! The main difference between this pallet and `frame/pallet-staking` is that this pallet

//! uses direct delegation. Delegators choose exactly who they delegate and with what stake.

//! This is different from `frame/pallet-staking` where delegators approval vote and run Phragmen.

//!

//! ### Rules

//! There is a new round every `<Round<T>>::get().length` blocks.

//!

//! At the start of every round,

//! * issuance is calculated for collators (and their delegators) for block authoring

//! `T::RewardPaymentDelay` rounds ago

//! * a new set of collators is chosen from the candidates

//!

//! Immediately following a round change, payments are made once-per-block until all payments have

//! been made. In each such block, one collator is chosen for a rewards payment and is paid along

//! with each of its top `T::MaxTopDelegationsPerCandidate` delegators.

//!

//! To join the set of candidates, call `join_candidates` with `bond >= MinCandidateStk`.

//! To leave the set of candidates, call `schedule_leave_candidates`. If the call succeeds,

//! the collator is removed from the pool of candidates so they cannot be selected for future

//! collator sets, but they are not unbonded until their exit request is executed. Any signed

//! account may trigger the exit `T::LeaveCandidatesDelay` rounds after the round in which the

//! original request was made.

//!

//! To join the set of delegators, call `delegate` and pass in an account that is

//! already a collator candidate and `bond >= MinDelegation`. Each delegator can delegate up to

//! `T::MaxDelegationsPerDelegator` collator candidates by calling `delegate`.

//!

//! To revoke a delegation, call `revoke_delegation` with the collator candidate's account.

//! To leave the set of delegators and revoke all delegations, call `leave_delegators`.

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

mod auto_compound;

mod delegation_requests;

pub mod inflation;

pub mod migrations;

pub mod traits;

pub mod types;

pub mod weights;

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

mod benchmarks;

#[cfg(test)]

mod mock;

mod set;

#[cfg(test)]

mod tests;

use frame_support::pallet;

pub use inflation::{InflationInfo, Range};

pub use weights::WeightInfo;

pub use auto_compound::{AutoCompoundConfig, AutoCompoundDelegations};

pub use delegation_requests::{CancelledScheduledRequest, DelegationAction, ScheduledRequest};

pub use pallet::*;

pub use traits::*;

pub use types::*;

pub use RoundIndex;

#[pallet]

pub mod pallet {

	use crate::delegation_requests::{

		CancelledScheduledRequest, DelegationAction, ScheduledRequest,

	};

	use crate::{set::BoundedOrderedSet, traits::*, types::*, InflationInfo, Range, WeightInfo};

	use crate::{AutoCompoundConfig, AutoCompoundDelegations};

	use frame_support::dispatch::DispatchResultWithPostInfo;

	use frame_support::pallet_prelude::*;

	use frame_support::traits::{

		fungible::{Balanced, Inspect, InspectHold, Mutate, MutateFreeze},

		Get,

	};

	use frame_system::pallet_prelude::*;

	use sp_consensus_slots::Slot;

	use sp_runtime::{

		traits::{Saturating, Zero},

		DispatchErrorWithPostInfo, Perbill, Percent,

	};

	use sp_std::{collections::btree_map::BTreeMap, prelude::*};

	/// Pallet for parachain staking

	#[pallet::pallet]

	#[pallet::without_storage_info]

	pub struct Pallet<T>(PhantomData<T>);

	pub type RoundIndex = u32;

	type RewardPoint = u32;

	pub type BalanceOf<T> =

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

	/// A hard limit for weight computation purposes for the max candidates that _could_

	/// theoretically exist.

	pub const MAX_CANDIDATES: u32 = 200;

	/// Configuration trait of this pallet.

	#[pallet::config]

	pub trait Config: frame_system::Config<RuntimeEvent: From<Event<Self>>> {

		/// The fungible type for handling balances

		type Currency: Inspect<Self::AccountId>

			+ InspectHold<Self::AccountId>

			+ Mutate<Self::AccountId>

			+ MutateFreeze<Self::AccountId, Id = Self::RuntimeFreezeReason>

			+ Balanced<Self::AccountId>;

		/// The overarching freeze identifier type.

		type RuntimeFreezeReason: From<FreezeReason>;

		/// The origin for monetary governance

		type MonetaryGovernanceOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Minimum number of blocks per round

		#[pallet::constant]

		type MinBlocksPerRound: Get<u32>;

		/// If a collator doesn't produce any block on this number of rounds, it is notified as inactive.

		/// This value must be less than or equal to RewardPaymentDelay.

		#[pallet::constant]

		type MaxOfflineRounds: Get<u32>;

		/// Number of rounds that candidates remain bonded before exit request is executable

		#[pallet::constant]

		type LeaveCandidatesDelay: Get<RoundIndex>;

		/// Number of rounds candidate requests to decrease self-bond must wait to be executable

		#[pallet::constant]

		type CandidateBondLessDelay: Get<RoundIndex>;

		/// Number of rounds that delegators remain bonded before exit request is executable

		#[pallet::constant]

		type LeaveDelegatorsDelay: Get<RoundIndex>;

		/// Number of rounds that delegations remain bonded before revocation request is executable

		#[pallet::constant]

		type RevokeDelegationDelay: Get<RoundIndex>;

		/// Number of rounds that delegation less requests must wait before executable

		#[pallet::constant]

		type DelegationBondLessDelay: Get<RoundIndex>;

		/// Number of rounds after which block authors are rewarded

		#[pallet::constant]

		type RewardPaymentDelay: Get<RoundIndex>;

		/// Minimum number of selected candidates every round

		#[pallet::constant]

		type MinSelectedCandidates: Get<u32>;

		/// Maximum top delegations counted per candidate

		#[pallet::constant]

		type MaxTopDelegationsPerCandidate: Get<u32>;

		/// Maximum bottom delegations (not counted) per candidate

		#[pallet::constant]

		type MaxBottomDelegationsPerCandidate: Get<u32>;

		/// Maximum delegations per delegator

		#[pallet::constant]

		type MaxDelegationsPerDelegator: Get<u32>;

		/// Minimum stake required for any account to be a collator candidate

		#[pallet::constant]

		type MinCandidateStk: Get<BalanceOf<Self>>;

		/// Minimum stake for any registered on-chain account to delegate

		#[pallet::constant]

		type MinDelegation: Get<BalanceOf<Self>>;

		/// Get the current block author

		type BlockAuthor: Get<Self::AccountId>;

		/// Handler to notify the runtime when a collator is paid.

		/// If you don't need it, you can specify the type `()`.

		type OnCollatorPayout: OnCollatorPayout<Self::AccountId, BalanceOf<Self>>;

		/// Handler to distribute a collator's reward.

		/// To use the default implementation of minting rewards, specify the type `()`.

		type PayoutCollatorReward: PayoutCollatorReward<Self>;

		/// Handler to notify the runtime when a collator is inactive.

		/// The default behavior is to mark the collator as offline.

		/// If you need to use the default implementation, specify the type `()`.

		type OnInactiveCollator: OnInactiveCollator<Self>;

		/// Handler to notify the runtime when a new round begin.

		/// If you don't need it, you can specify the type `()`.

		type OnNewRound: OnNewRound;

		/// Get the current slot number

		type SlotProvider: Get<Slot>;

		/// Get the slot duration in milliseconds

		#[pallet::constant]

		type SlotDuration: Get<u64>;

		/// Get the average time between 2 blocks in milliseconds

		#[pallet::constant]

		type BlockTime: Get<u64>;

		/// Maximum candidates

		#[pallet::constant]

		type MaxCandidates: Get<u32>;

		/// Threshold after which inflation become linear

		/// If you don't want to use it, set it to `()`

		#[pallet::constant]

		type LinearInflationThreshold: Get<Option<BalanceOf<Self>>>;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

	}

	/// The reason for freezing funds.

	#[pallet::composite_enum]

	pub enum FreezeReason {

		/// Funds frozen for staking as a collator

		StakingCollator,

		/// Funds frozen for staking as a delegator

		StakingDelegator,

	}

	#[pallet::error]

	pub enum Error<T> {

		DelegatorDNE,

		DelegatorDNEinTopNorBottom,

		DelegatorDNEInDelegatorSet,

		CandidateDNE,

		DelegationDNE,

		DelegatorExists,

		CandidateExists,

		CandidateBondBelowMin,

		InsufficientBalance,

		DelegatorBondBelowMin,

		DelegationBelowMin,

		AlreadyOffline,

		AlreadyActive,

		DelegatorAlreadyLeaving,

		DelegatorNotLeaving,

		DelegatorCannotLeaveYet,

		CannotDelegateIfLeaving,

		CandidateAlreadyLeaving,

		CandidateNotLeaving,

		CandidateCannotLeaveYet,

		CannotGoOnlineIfLeaving,

		ExceedMaxDelegationsPerDelegator,

		AlreadyDelegatedCandidate,

		InvalidSchedule,

		CannotSetBelowMin,

		RoundLengthMustBeGreaterThanTotalSelectedCollators,

		NoWritingSameValue,

		TotalInflationDistributionPercentExceeds100,

		TooLowCandidateCountWeightHintJoinCandidates,

		TooLowCandidateCountWeightHintCancelLeaveCandidates,

		TooLowCandidateCountToLeaveCandidates,

		TooLowDelegationCountToDelegate,

		TooLowCandidateDelegationCountToDelegate,

		TooLowCandidateDelegationCountToLeaveCandidates,

		TooLowDelegationCountToLeaveDelegators,

		PendingCandidateRequestsDNE,

		PendingCandidateRequestAlreadyExists,

		PendingCandidateRequestNotDueYet,

		PendingDelegationRequestDNE,

		PendingDelegationRequestAlreadyExists,

		PendingDelegationRequestNotDueYet,

		CannotDelegateLessThanOrEqualToLowestBottomWhenFull,

		PendingDelegationRevoke,

		TooLowDelegationCountToAutoCompound,

		TooLowCandidateAutoCompoundingDelegationCountToAutoCompound,

		TooLowCandidateAutoCompoundingDelegationCountToDelegate,

		TooLowCollatorCountToNotifyAsInactive,

		CannotBeNotifiedAsInactive,

		TooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates,

		TooLowCandidateCountWeightHint,

		TooLowCandidateCountWeightHintGoOffline,

		CandidateLimitReached,

		CannotSetAboveMaxCandidates,

		MarkingOfflineNotEnabled,

		CurrentRoundTooLow,

		EmptyMigrationBatch,

	}

	#[pallet::event]

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

	pub enum Event<T: Config> {

		/// Started new round.

		NewRound {

			starting_block: BlockNumberFor<T>,

			round: RoundIndex,

			selected_collators_number: u32,

			total_balance: BalanceOf<T>,

		},

		/// Account joined the set of collator candidates.

		JoinedCollatorCandidates {

			account: T::AccountId,

			amount_locked: BalanceOf<T>,

			new_total_amt_locked: BalanceOf<T>,

		},

		/// Candidate selected for collators. Total Exposed Amount includes all delegations.

		CollatorChosen {

			round: RoundIndex,

			collator_account: T::AccountId,

			total_exposed_amount: BalanceOf<T>,

		},

		/// Candidate requested to decrease a self bond.

		CandidateBondLessRequested {

			candidate: T::AccountId,

			amount_to_decrease: BalanceOf<T>,

			execute_round: RoundIndex,

		},

		/// Candidate has increased a self bond.

		CandidateBondedMore {

			candidate: T::AccountId,

			amount: BalanceOf<T>,

			new_total_bond: BalanceOf<T>,

		},

		/// Candidate has decreased a self bond.

		CandidateBondedLess {

			candidate: T::AccountId,

			amount: BalanceOf<T>,

			new_bond: BalanceOf<T>,

		},

		/// Candidate temporarily leave the set of collator candidates without unbonding.

		CandidateWentOffline { candidate: T::AccountId },

		/// Candidate rejoins the set of collator candidates.

		CandidateBackOnline { candidate: T::AccountId },

		/// Candidate has requested to leave the set of candidates.

		CandidateScheduledExit {

			exit_allowed_round: RoundIndex,

			candidate: T::AccountId,

			scheduled_exit: RoundIndex,

		},

		/// Cancelled request to leave the set of candidates.

		CancelledCandidateExit { candidate: T::AccountId },

		/// Cancelled request to decrease candidate's bond.

		CancelledCandidateBondLess {

			candidate: T::AccountId,

			amount: BalanceOf<T>,

			execute_round: RoundIndex,

		},

		/// Candidate has left the set of candidates.

		CandidateLeft {

			ex_candidate: T::AccountId,

			unlocked_amount: BalanceOf<T>,

			new_total_amt_locked: BalanceOf<T>,

		},

		/// Delegator requested to decrease a bond for the collator candidate.

		DelegationDecreaseScheduled {

			delegator: T::AccountId,

			candidate: T::AccountId,

			amount_to_decrease: BalanceOf<T>,

			execute_round: RoundIndex,

		},

		// Delegation increased.

		DelegationIncreased {

			delegator: T::AccountId,

			candidate: T::AccountId,

			amount: BalanceOf<T>,

			in_top: bool,

		},

		// Delegation decreased.

		DelegationDecreased {

			delegator: T::AccountId,

			candidate: T::AccountId,

			amount: BalanceOf<T>,

			in_top: bool,

		},

		/// Delegator requested to leave the set of delegators.

		DelegatorExitScheduled {

			round: RoundIndex,

			delegator: T::AccountId,

			scheduled_exit: RoundIndex,

		},

		/// Delegator requested to revoke delegation.

		DelegationRevocationScheduled {

			round: RoundIndex,

			delegator: T::AccountId,

			candidate: T::AccountId,

			scheduled_exit: RoundIndex,

		},

		/// Delegator has left the set of delegators.

		DelegatorLeft {

			delegator: T::AccountId,

			unstaked_amount: BalanceOf<T>,

		},

		/// Delegation revoked.

		DelegationRevoked {

			delegator: T::AccountId,

			candidate: T::AccountId,

			unstaked_amount: BalanceOf<T>,

		},

		/// Delegation kicked.

		DelegationKicked {

			delegator: T::AccountId,

			candidate: T::AccountId,

			unstaked_amount: BalanceOf<T>,

		},

		/// Cancelled a pending request to exit the set of delegators.

		DelegatorExitCancelled { delegator: T::AccountId },

		/// Cancelled request to change an existing delegation.

		CancelledDelegationRequest {

			delegator: T::AccountId,

			cancelled_request: CancelledScheduledRequest<BalanceOf<T>>,

			collator: T::AccountId,

		},

		/// New delegation (increase of the existing one).

		Delegation {

			delegator: T::AccountId,

			locked_amount: BalanceOf<T>,

			candidate: T::AccountId,

			delegator_position: DelegatorAdded<BalanceOf<T>>,

			auto_compound: Percent,

		},

		/// Delegation from candidate state has been removed.

		DelegatorLeftCandidate {

			delegator: T::AccountId,

			candidate: T::AccountId,

			unstaked_amount: BalanceOf<T>,

			total_candidate_staked: BalanceOf<T>,

		},

		/// Paid the account (delegator or collator) the balance as liquid rewards.

		Rewarded {

			account: T::AccountId,

			rewards: BalanceOf<T>,

		},

		/// Transferred to account which holds funds reserved for parachain bond.

		InflationDistributed {

			index: u32,

			account: T::AccountId,

			value: BalanceOf<T>,

		},

		InflationDistributionConfigUpdated {

			old: InflationDistributionConfig<T::AccountId>,

			new: InflationDistributionConfig<T::AccountId>,

		},

		/// Annual inflation input (first 3) was used to derive new per-round inflation (last 3)

		InflationSet {

			annual_min: Perbill,

			annual_ideal: Perbill,

			annual_max: Perbill,

			round_min: Perbill,

			round_ideal: Perbill,

			round_max: Perbill,

		},

		/// Staking expectations set.

		StakeExpectationsSet {

			expect_min: BalanceOf<T>,

			expect_ideal: BalanceOf<T>,

			expect_max: BalanceOf<T>,

		},

		/// Set total selected candidates to this value.

		TotalSelectedSet { old: u32, new: u32 },

		/// Set collator commission to this value.

		CollatorCommissionSet { old: Perbill, new: Perbill },

		/// Set blocks per round

		BlocksPerRoundSet {

			current_round: RoundIndex,

			first_block: BlockNumberFor<T>,

			old: u32,

			new: u32,

			new_per_round_inflation_min: Perbill,

			new_per_round_inflation_ideal: Perbill,

			new_per_round_inflation_max: Perbill,

		},

		/// Auto-compounding reward percent was set for a delegation.

		AutoCompoundSet {

			candidate: T::AccountId,

			delegator: T::AccountId,

			value: Percent,

		},

		/// Compounded a portion of rewards towards the delegation.

		Compounded {

			candidate: T::AccountId,

			delegator: T::AccountId,

			amount: BalanceOf<T>,

		},

	}

	#[pallet::hooks]

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

			// add on_finalize weight

			//   read:  Author, Points, AwardedPts, WasInactive

			//   write: Points, AwardedPts, WasInactive

	}

	#[pallet::storage]

	#[pallet::getter(fn collator_commission)]

	/// Commission percent taken off of rewards for all collators

	type CollatorCommission<T: Config> = StorageValue<_, Perbill, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn total_selected)]

	/// The total candidates selected every round

	pub(crate) type TotalSelected<T: Config> = StorageValue<_, u32, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn inflation_distribution_info)]

	/// Inflation distribution configuration, including accounts that should receive inflation

	/// before it is distributed to collators and delegators.

	///

	/// The sum of the distribution percents must be less than or equal to 100.

	pub(crate) type InflationDistributionInfo<T: Config> =

		StorageValue<_, InflationDistributionConfig<T::AccountId>, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn round)]

	/// Current round index and next round scheduled transition

	pub type Round<T: Config> = StorageValue<_, RoundInfo<BlockNumberFor<T>>, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn delegator_state)]

	/// Get delegator state associated with an account if account is delegating else None

	pub(crate) type DelegatorState<T: Config> = StorageMap<

		_,

		Twox64Concat,

		T::AccountId,

		Delegator<T::AccountId, BalanceOf<T>>,

		OptionQuery,

	>;

	#[pallet::storage]

	#[pallet::getter(fn candidate_info)]

	/// Get collator candidate info associated with an account if account is candidate else None

	pub(crate) type CandidateInfo<T: Config> =

		StorageMap<_, Twox64Concat, T::AccountId, CandidateMetadata<BalanceOf<T>>, OptionQuery>;

	pub struct AddGet<T, R> {

		_phantom: PhantomData<(T, R)>,

	}

	impl<T, R> Get<u32> for AddGet<T, R>

	where

		T: Get<u32>,

		R: Get<u32>,

	{

	}

	/// Stores outstanding delegation requests per collator.

	#[pallet::storage]

	#[pallet::getter(fn delegation_scheduled_requests)]

	pub(crate) type DelegationScheduledRequests<T: Config> = StorageMap<

		_,

		Blake2_128Concat,

		T::AccountId,

		BoundedVec<

			ScheduledRequest<T::AccountId, BalanceOf<T>>,

			AddGet<T::MaxTopDelegationsPerCandidate, T::MaxBottomDelegationsPerCandidate>,

		>,

		ValueQuery,

	>;

	/// Stores auto-compounding configuration per collator.

	#[pallet::storage]

	#[pallet::getter(fn auto_compounding_delegations)]

	pub(crate) type AutoCompoundingDelegations<T: Config> = StorageMap<

		_,

		Blake2_128Concat,

		T::AccountId,

		BoundedVec<

			AutoCompoundConfig<T::AccountId>,

			AddGet<T::MaxTopDelegationsPerCandidate, T::MaxBottomDelegationsPerCandidate>,

		>,

		ValueQuery,

	>;

	#[pallet::storage]

	#[pallet::getter(fn top_delegations)]

	/// Top delegations for collator candidate

	pub(crate) type TopDelegations<T: Config> = StorageMap<

		_,

		Twox64Concat,

		T::AccountId,

		Delegations<T::AccountId, BalanceOf<T>>,

		OptionQuery,

	>;

	#[pallet::storage]

	#[pallet::getter(fn bottom_delegations)]

	/// Bottom delegations for collator candidate

	pub(crate) type BottomDelegations<T: Config> = StorageMap<

		_,

		Twox64Concat,

		T::AccountId,

		Delegations<T::AccountId, BalanceOf<T>>,

		OptionQuery,

	>;

	#[pallet::storage]

	#[pallet::getter(fn selected_candidates)]

	/// The collator candidates selected for the current round

	type SelectedCandidates<T: Config> =

		StorageValue<_, BoundedVec<T::AccountId, T::MaxCandidates>, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn total)]

	/// Total capital locked by this staking pallet

	pub(crate) type Total<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn candidate_pool)]

	/// The pool of collator candidates, each with their total backing stake

	pub(crate) type CandidatePool<T: Config> = StorageValue<

		_,

		BoundedOrderedSet<Bond<T::AccountId, BalanceOf<T>>, T::MaxCandidates>,

		ValueQuery,

	>;

	#[pallet::storage]

	#[pallet::getter(fn at_stake)]

	/// Snapshot of collator delegation stake at the start of the round

	pub type AtStake<T: Config> = StorageDoubleMap<

		_,

		Twox64Concat,

		RoundIndex,

		Twox64Concat,

		T::AccountId,

		CollatorSnapshot<T::AccountId, BalanceOf<T>>,

		OptionQuery,

	>;

	#[pallet::storage]

	#[pallet::getter(fn was_inactive)]

	/// Records collators' inactivity.

	/// Data persists for MaxOfflineRounds + 1 rounds before being pruned.

	pub type WasInactive<T: Config> =

		StorageDoubleMap<_, Twox64Concat, RoundIndex, Twox64Concat, T::AccountId, (), OptionQuery>;

	#[pallet::storage]

	#[pallet::getter(fn delayed_payouts)]

	/// Delayed payouts

	pub type DelayedPayouts<T: Config> =

		StorageMap<_, Twox64Concat, RoundIndex, DelayedPayout<BalanceOf<T>>, OptionQuery>;

	#[pallet::storage]

	#[pallet::getter(fn inflation_config)]

	/// Inflation configuration

	pub type InflationConfig<T: Config> = StorageValue<_, InflationInfo<BalanceOf<T>>, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn points)]

	/// Total points awarded to collators for block production in the round

	pub type Points<T: Config> = StorageMap<_, Twox64Concat, RoundIndex, RewardPoint, ValueQuery>;

	#[pallet::storage]

	#[pallet::getter(fn awarded_pts)]

	/// Points for each collator per round

	pub type AwardedPts<T: Config> = StorageDoubleMap<

		_,

		Twox64Concat,

		RoundIndex,

		Twox64Concat,

		T::AccountId,

		RewardPoint,

		ValueQuery,

	>;

	#[pallet::storage]

	#[pallet::getter(fn marking_offline)]

	/// Killswitch to enable/disable marking offline feature.

	pub type EnableMarkingOffline<T: Config> = StorageValue<_, bool, ValueQuery>;

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config> {

		/// Initialize balance and register all as collators: `(collator AccountId, balance Amount)`

		pub candidates: Vec<(T::AccountId, BalanceOf<T>)>,

		/// Initialize balance and make delegations:

		/// `(delegator AccountId, collator AccountId, delegation Amount, auto-compounding Percent)`

		pub delegations: Vec<(T::AccountId, T::AccountId, BalanceOf<T>, Percent)>,

		/// Inflation configuration

		pub inflation_config: InflationInfo<BalanceOf<T>>,

		/// Default fixed percent a collator takes off the top of due rewards

		pub collator_commission: Perbill,

		/// Default percent of inflation set aside for parachain bond every round

		pub parachain_bond_reserve_percent: Percent,

		/// Default number of blocks in a round

		pub blocks_per_round: u32,

		/// Number of selected candidates every round. Cannot be lower than MinSelectedCandidates

		pub num_selected_candidates: u32,

	}

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

	}

	#[pallet::genesis_build]

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

			// Initialize the candidates

				);

			}

			// Initialize the delegations

				);

				} else {

				};

				} else {

				};

				} else {

				}

			}

			// Set collator commission to default config

			// Set parachain bond config to default config

			);

			// Set total selected candidates to value from config

				Error::<T>::CannotSetBelowMin

			);

				Error::<T>::CannotSetAboveMaxCandidates

			);

			// Choose top TotalSelected collator candidates

			// Start Round 1 at Block 0

	}

	#[pallet::call]

	impl<T: Config> Pallet<T> {

		/// Set the expectations for total staked. These expectations determine the issuance for

		/// the round according to logic in `fn compute_issuance`

		#[pallet::call_index(0)]

		#[pallet::weight(<T as Config>::WeightInfo::set_staking_expectations())]

		pub fn set_staking_expectations(

			origin: OriginFor<T>,

			expectations: Range<BalanceOf<T>>,

			);

		}

		/// Set the annual inflation rate to derive per-round inflation

		#[pallet::call_index(1)]

		#[pallet::weight(<T as Config>::WeightInfo::set_inflation())]

		pub fn set_inflation(

			origin: OriginFor<T>,

			schedule: Range<Perbill>,

		}

		/// Set the total number of collator candidates selected per round

		/// - changes are not applied until the start of the next round

		#[pallet::call_index(4)]

		#[pallet::weight(<T as Config>::WeightInfo::set_total_selected())]

			);

			);

			);

		}

		/// Set the commission for all collators

		#[pallet::call_index(5)]

		#[pallet::weight(<T as Config>::WeightInfo::set_collator_commission())]

		pub fn set_collator_commission(

			origin: OriginFor<T>,

			new: Perbill,

		}

		/// Set blocks per round

		/// - if called with `new` less than length of current round, will transition immediately

		/// in the next block

		/// - also updates per-round inflation config

		#[pallet::call_index(6)]

		#[pallet::weight(<T as Config>::WeightInfo::set_blocks_per_round())]

			);

			);

			// update per-round inflation given new rounds per year

		}

		/// Join the set of collator candidates

		#[pallet::call_index(7)]

		#[pallet::weight(<T as Config>::WeightInfo::join_candidates(*candidate_count))]

		pub fn join_candidates(

			origin: OriginFor<T>,

			bond: BalanceOf<T>,

			candidate_count: u32,

			);

		}

		/// Request to leave the set of candidates. If successful, the account is immediately

		/// removed from the candidate pool to prevent selection as a collator.

		#[pallet::call_index(8)]

		#[pallet::weight(<T as Config>::WeightInfo::schedule_leave_candidates(*candidate_count))]

		pub fn schedule_leave_candidates(

			origin: OriginFor<T>,

			candidate_count: u32,

			);

		}

		/// Execute leave candidates request

		#[pallet::call_index(9)]

		#[pallet::weight(

			<T as Config>::WeightInfo::execute_leave_candidates_worst_case(*candidate_delegation_count)

		)]

		pub fn execute_leave_candidates(

			origin: OriginFor<T>,

			candidate: T::AccountId,

			candidate_delegation_count: u32,

			);

		}

		/// Cancel open request to leave candidates

		/// - only callable by collator account

		/// - result upon successful call is the candidate is active in the candidate pool

		#[pallet::call_index(10)]

		#[pallet::weight(<T as Config>::WeightInfo::cancel_leave_candidates(*candidate_count))]

		pub fn cancel_leave_candidates(

			origin: OriginFor<T>,

			candidate_count: u32,

			);

		}

		/// Temporarily leave the set of collator candidates without unbonding

		#[pallet::call_index(11)]

		#[pallet::weight(<T as Config>::WeightInfo::go_offline(MAX_CANDIDATES))]

		}

		/// Rejoin the set of collator candidates if previously had called `go_offline`

		#[pallet::call_index(12)]

		#[pallet::weight(<T as Config>::WeightInfo::go_online(MAX_CANDIDATES))]

		}

		/// Increase collator candidate self bond by `more`

		#[pallet::call_index(13)]

		#[pallet::weight(<T as Config>::WeightInfo::candidate_bond_more(MAX_CANDIDATES))]

		pub fn candidate_bond_more(

			origin: OriginFor<T>,

			more: BalanceOf<T>,

		}

		/// Request by collator candidate to decrease self bond by `less`

		#[pallet::call_index(14)]

		#[pallet::weight(<T as Config>::WeightInfo::schedule_candidate_bond_less())]

		pub fn schedule_candidate_bond_less(

			origin: OriginFor<T>,

			less: BalanceOf<T>,

		}

		/// Execute pending request to adjust the collator candidate self bond

		#[pallet::call_index(15)]

		#[pallet::weight(<T as Config>::WeightInfo::execute_candidate_bond_less(MAX_CANDIDATES))]

		pub fn execute_candidate_bond_less(

			origin: OriginFor<T>,

			candidate: T::AccountId,

		}

		/// Cancel pending request to adjust the collator candidate self bond

		#[pallet::call_index(16)]

		#[pallet::weight(<T as Config>::WeightInfo::cancel_candidate_bond_less())]

		}

		/// If caller is not a delegator and not a collator, then join the set of delegators

		/// If caller is a delegator, then makes delegation to change their delegation state

		/// Sets the auto-compound config for the delegation

		#[pallet::call_index(18)]

		#[pallet::weight(

			<T as Config>::WeightInfo::delegate_with_auto_compound(

				*candidate_delegation_count,

				*candidate_auto_compounding_delegation_count,

				*delegation_count,

			)

		)]

		pub fn delegate_with_auto_compound(

			origin: OriginFor<T>,

			candidate: T::AccountId,

			amount: BalanceOf<T>,

			auto_compound: Percent,

			candidate_delegation_count: u32,

			candidate_auto_compounding_delegation_count: u32,

			delegation_count: u32,

			)

		}

		/// Request to revoke an existing delegation. If successful, the delegation is scheduled

		/// to be allowed to be revoked via the `execute_delegation_request` extrinsic.

		/// The delegation receives no rewards for the rounds while a revoke is pending.

		/// A revoke may not be performed if any other scheduled request is pending.

		#[pallet::call_index(22)]

		#[pallet::weight(<T as Config>::WeightInfo::schedule_revoke_delegation(

			T::MaxTopDelegationsPerCandidate::get() + T::MaxBottomDelegationsPerCandidate::get()

		))]

		pub fn schedule_revoke_delegation(

			origin: OriginFor<T>,

			collator: T::AccountId,

		}

		/// Bond more for delegators wrt a specific collator candidate.

		#[pallet::call_index(23)]

		#[pallet::weight(<T as Config>::WeightInfo::delegator_bond_more(

			T::MaxTopDelegationsPerCandidate::get() + T::MaxBottomDelegationsPerCandidate::get()

		))]

		pub fn delegator_bond_more(

			origin: OriginFor<T>,

			candidate: T::AccountId,

			more: BalanceOf<T>,

		}

		/// Request bond less for delegators wrt a specific collator candidate. The delegation's

		/// rewards for rounds while the request is pending use the reduced bonded amount.

		/// A bond less may not be performed if any other scheduled request is pending.

		#[pallet::call_index(24)]

		#[pallet::weight(<T as Config>::WeightInfo::schedule_delegator_bond_less(

			T::MaxTopDelegationsPerCandidate::get() + T::MaxBottomDelegationsPerCandidate::get()

		))]

		pub fn schedule_delegator_bond_less(

			origin: OriginFor<T>,

			candidate: T::AccountId,

			less: BalanceOf<T>,

		}

		/// Execute pending request to change an existing delegation

		#[pallet::call_index(25)]

		#[pallet::weight(<T as Config>::WeightInfo::execute_delegator_revoke_delegation_worst())]

		pub fn execute_delegation_request(

			origin: OriginFor<T>,

			delegator: T::AccountId,

			candidate: T::AccountId,

		}

		/// Cancel request to change an existing delegation.

		#[pallet::call_index(26)]

		#[pallet::weight(<T as Config>::WeightInfo::cancel_delegation_request(350))]

		pub fn cancel_delegation_request(

			origin: OriginFor<T>,

			candidate: T::AccountId,

		}

		/// Sets the auto-compounding reward percentage for a delegation.

		#[pallet::call_index(27)]

		#[pallet::weight(<T as Config>::WeightInfo::set_auto_compound(

			*candidate_auto_compounding_delegation_count_hint,

			*delegation_count_hint,

		))]

		pub fn set_auto_compound(

			origin: OriginFor<T>,

			candidate: T::AccountId,

			value: Percent,

			candidate_auto_compounding_delegation_count_hint: u32,

			delegation_count_hint: u32,

			)

		}

		/// Notify a collator is inactive during MaxOfflineRounds

		#[pallet::call_index(29)]

		#[pallet::weight(<T as Config>::WeightInfo::notify_inactive_collator())]

		pub fn notify_inactive_collator(

			origin: OriginFor<T>,

			collator: T::AccountId,

			);

			// Check collators length is not below or eq to 66% of max_collators.

			// We use saturating logic here with (2/3)

			// as it is dangerous to use floating point numbers directly.

			);

			);

			// Have rounds_to_check = [8,9]

			// in case we are in round 10 for instance

			// with MaxOfflineRounds = 2

			// If this counter is eq to max_offline_rounds,

			// the collator should be notified as inactive

			// Iter rounds and check whether the collator has been inactive