// This file is part of Substrate.

// Copyright (C) Parity Technologies (UK) Ltd.

// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// 	http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//! GRANDPA Consensus module for runtime.

//!

//! This manages the GRANDPA authority set ready for the native code.

//! These authorities are only for GRANDPA finality, not for consensus overall.

//!

//! In the future, it will also handle misbehavior reports, and on-chain

//! finality notifications.

//!

//! For full integration with GRANDPA, the `GrandpaApi` should be implemented.

//! The necessary items are re-exported via the `fg_primitives` crate.

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

extern crate alloc;

// Re-export since this is necessary for `impl_apis` in runtime.

pub use sp_consensus_grandpa::{

	self as fg_primitives, AuthorityId, AuthorityList, AuthorityWeight,

};

use alloc::{boxed::Box, vec::Vec};

use codec::{Decode, Encode, MaxEncodedLen};

use frame_support::{

	dispatch::{DispatchResultWithPostInfo, Pays},

	pallet_prelude::Get,

	traits::OneSessionHandler,

	weights::Weight,

	WeakBoundedVec,

};

use frame_system::pallet_prelude::BlockNumberFor;

use scale_info::TypeInfo;

use sp_consensus_grandpa::{

	ConsensusLog, EquivocationProof, ScheduledChange, SetId, GRANDPA_ENGINE_ID,

	RUNTIME_LOG_TARGET as LOG_TARGET,

};

use sp_runtime::{generic::DigestItem, traits::Zero, DispatchResult};

use sp_session::{GetSessionNumber, GetValidatorCount};

use sp_staking::{offence::OffenceReportSystem, SessionIndex};

mod default_weights;

mod equivocation;

pub mod migrations;

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

mod benchmarking;

#[cfg(all(feature = "std", test))]

mod mock;

#[cfg(all(feature = "std", test))]

mod tests;

pub use equivocation::{EquivocationOffence, EquivocationReportSystem, TimeSlot};

pub use pallet::*;

pub mod pallet {

	use super::*;

	use frame_support::{dispatch::DispatchResult, pallet_prelude::*};

	use frame_system::pallet_prelude::*;

	/// The in-code storage version.

	const STORAGE_VERSION: StorageVersion = StorageVersion::new(5);

	#[pallet::storage_version(STORAGE_VERSION)]

	pub struct Pallet<T>(_);

	#[pallet::config]

	pub trait Config: frame_system::Config {

		/// The event type of this module.

		type RuntimeEvent: From<Event>

			+ Into<<Self as frame_system::Config>::RuntimeEvent>

			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// Weights for this pallet.

		type WeightInfo: WeightInfo;

		/// Max Authorities in use

		#[pallet::constant]

		type MaxAuthorities: Get<u32>;

		/// The maximum number of nominators for each validator.

		#[pallet::constant]

		type MaxNominators: Get<u32>;

		/// The maximum number of entries to keep in the set id to session index mapping.

		///

		/// Since the `SetIdSession` map is only used for validating equivocations this

		/// value should relate to the bonding duration of whatever staking system is

		/// being used (if any). If equivocation handling is not enabled then this value

		/// can be zero.

		#[pallet::constant]

		type MaxSetIdSessionEntries: Get<u64>;

		/// The proof of key ownership, used for validating equivocation reports

		/// The proof include the session index and validator count of the

		/// session at which the equivocation occurred.

		type KeyOwnerProof: Parameter + GetSessionNumber + GetValidatorCount;

		/// The equivocation handling subsystem, defines methods to check/report an

		/// offence and for submitting a transaction to report an equivocation

		/// (from an offchain context).

		type EquivocationReportSystem: OffenceReportSystem<

			Option<Self::AccountId>,

			(EquivocationProof<Self::Hash, BlockNumberFor<Self>>, Self::KeyOwnerProof),

		>;

	}

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

			// check for scheduled pending authority set changes

				// emit signal if we're at the block that scheduled the change

				// enact the change if we've reached the enacting block

			// check for scheduled pending state changes

					// enact change to paused state

				},

					// enact change to live state

				},

			}

	}

	impl<T: Config> Pallet<T> {

		/// Report voter equivocation/misbehavior. This method will verify the

		/// equivocation proof and validate the given key ownership proof

		/// against the extracted offender. If both are valid, the offence

		/// will be reported.

		#[pallet::call_index(0)]

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

			key_owner_proof.validator_count(),

			T::MaxNominators::get(),

		))]

		pub fn report_equivocation(

			origin: OriginFor<T>,

			equivocation_proof: Box<EquivocationProof<T::Hash, BlockNumberFor<T>>>,

			key_owner_proof: T::KeyOwnerProof,

			// Waive the fee since the report is valid and beneficial

		}

		/// Report voter equivocation/misbehavior. This method will verify the

		/// equivocation proof and validate the given key ownership proof

		/// against the extracted offender. If both are valid, the offence

		/// will be reported.

		///

		/// This extrinsic must be called unsigned and it is expected that only

		/// block authors will call it (validated in `ValidateUnsigned`), as such

		/// if the block author is defined it will be defined as the equivocation

		/// reporter.

		#[pallet::call_index(1)]

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

			key_owner_proof.validator_count(),

			T::MaxNominators::get(),

		))]

		pub fn report_equivocation_unsigned(

			origin: OriginFor<T>,

			equivocation_proof: Box<EquivocationProof<T::Hash, BlockNumberFor<T>>>,

			key_owner_proof: T::KeyOwnerProof,

		}

		/// Note that the current authority set of the GRANDPA finality gadget has stalled.

		///

		/// This will trigger a forced authority set change at the beginning of the next session, to

		/// be enacted `delay` blocks after that. The `delay` should be high enough to safely assume

		/// that the block signalling the forced change will not be re-orged e.g. 1000 blocks.

		/// The block production rate (which may be slowed down because of finality lagging) should

		/// be taken into account when choosing the `delay`. The GRANDPA voters based on the new

		/// authority will start voting on top of `best_finalized_block_number` for new finalized

		/// blocks. `best_finalized_block_number` should be the highest of the latest finalized

		/// block of all validators of the new authority set.

		///

		/// Only callable by root.

		#[pallet::call_index(2)]

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

		pub fn note_stalled(

			origin: OriginFor<T>,

			delay: BlockNumberFor<T>,

			best_finalized_block_number: BlockNumberFor<T>,

		}

	}

	pub enum Event {

	}

	pub enum Error<T> {

	}

	/// State of the current authority set.

	#[pallet::getter(fn state)]

	pub(super) type State<T: Config> =

		StorageValue<_, StoredState<BlockNumberFor<T>>, ValueQuery, DefaultForState<T>>;

	/// Pending change: (signaled at, scheduled change).

	#[pallet::getter(fn pending_change)]

	pub(super) type PendingChange<T: Config> =

		StorageValue<_, StoredPendingChange<BlockNumberFor<T>, T::MaxAuthorities>>;

	/// next block number where we can force a change.

	#[pallet::getter(fn next_forced)]

	pub(super) type NextForced<T: Config> = StorageValue<_, BlockNumberFor<T>>;

	/// `true` if we are currently stalled.

	#[pallet::getter(fn stalled)]

	pub(super) type Stalled<T: Config> = StorageValue<_, (BlockNumberFor<T>, BlockNumberFor<T>)>;

	/// The number of changes (both in terms of keys and underlying economic responsibilities)

	/// in the "set" of Grandpa validators from genesis.

	#[pallet::getter(fn current_set_id)]

	pub(super) type CurrentSetId<T: Config> = StorageValue<_, SetId, ValueQuery>;

	/// A mapping from grandpa set ID to the index of the *most recent* session for which its

	/// members were responsible.

	///

	/// This is only used for validating equivocation proofs. An equivocation proof must

	/// contains a key-ownership proof for a given session, therefore we need a way to tie

	/// together sessions and GRANDPA set ids, i.e. we need to validate that a validator

	/// was the owner of a given key on a given session, and what the active set ID was

	/// during that session.

	///

	/// TWOX-NOTE: `SetId` is not under user control.

	#[pallet::getter(fn session_for_set)]

	pub(super) type SetIdSession<T: Config> = StorageMap<_, Twox64Concat, SetId, SessionIndex>;

	/// The current list of authorities.

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

		StorageValue<_, BoundedAuthorityList<T::MaxAuthorities>, ValueQuery>;

	#[derive(frame_support::DefaultNoBound)]

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config> {

		pub authorities: AuthorityList,

		#[serde(skip)]

		pub _config: core::marker::PhantomData<T>,

	}

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

	}

	#[pallet::validate_unsigned]

	impl<T: Config> ValidateUnsigned for Pallet<T> {

		type Call = Call<T>;

	}

}

pub trait WeightInfo {

	fn report_equivocation(validator_count: u32, max_nominators_per_validator: u32) -> Weight;

	fn note_stalled() -> Weight;

}

/// Bounded version of `AuthorityList`, `Limit` being the bound

pub type BoundedAuthorityList<Limit> = WeakBoundedVec<(AuthorityId, AuthorityWeight), Limit>;

/// A stored pending change.

/// `Limit` is the bound for `next_authorities`

#[codec(mel_bound(N: MaxEncodedLen, Limit: Get<u32>))]

#[scale_info(skip_type_params(Limit))]

pub struct StoredPendingChange<N, Limit> {

	/// The block number this was scheduled at.

	pub scheduled_at: N,

	/// The delay in blocks until it will be applied.

	pub delay: N,

	/// The next authority set, weakly bounded in size by `Limit`.

	pub next_authorities: BoundedAuthorityList<Limit>,

	/// If defined it means the change was forced and the given block number

	/// indicates the median last finalized block when the change was signaled.

	pub forced: Option<N>,

}

/// Current state of the GRANDPA authority set. State transitions must happen in

/// the same order of states defined below, e.g. `Paused` implies a prior

/// `PendingPause`.

#[cfg_attr(test, derive(Debug, PartialEq))]

pub enum StoredState<N> {

	/// height.

	PendingPause {

	/// height.

	PendingResume {

}

impl<T: Config> Pallet<T> {

	/// Get the current set of authorities, along with their respective weights.

	/// Schedule GRANDPA to pause starting in the given number of blocks.

	/// Cannot be done when already paused.

		} else {

		}

	/// Schedule a resume of GRANDPA after pausing.

		} else {

		}

	/// Schedule a change in the authorities.

	///

	/// The change will be applied at the end of execution of the block

	/// `in_blocks` after the current block. This value may be 0, in which

	/// case the change is applied at the end of the current block.

	///

	/// If the `forced` parameter is defined, this indicates that the current

	/// set has been synchronously determined to be offline and that after

	/// `in_blocks` the given change should be applied. The given block number

	/// indicates the median last finalized block number and it should be used

	/// as the canon block when starting the new grandpa voter.

	///

	/// No change should be signaled while any change is pending. Returns

	/// an error if a change is already pending.

		} else {

		}

	/// Deposit one of this module's logs.

	// Perform module initialization, abstracted so that it can be called either through genesis

	// config builder or through `on_genesis_session`.

		// NOTE: initialize first session of first set. this is necessary for

		// the genesis set and session since we only update the set -> session

		// mapping whenever a new session starts, i.e. through `on_new_session`.

	/// Submits an extrinsic to report an equivocation. This method will create

	/// an unsigned extrinsic with a call to `report_equivocation_unsigned` and

	/// will push the transaction to the pool. Only useful in an offchain

	/// context.

}

impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {

	type Public = AuthorityId;

}

impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T>

where

	T: pallet_session::Config,

{

	type Key = AuthorityId;

		// Always issue a change if `session` says that the validators have changed.

		// Even if their session keys are the same as before, the underlying economic

		// identities have changed.

			} else {

			};

			} else {

				// either the session module signalled that the validators have changed

				// or the set was stalled. but since we didn't successfully schedule

				// an authority set change we do not increment the set id.

			}

		} else {

			// nothing's changed, neither economic conditions nor session keys. update the pointer

			// of the current set.

		};

		// update the mapping to note that the current set corresponds to the

		// latest equivalent session (i.e. now).

}