mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-05-31 05:11:02 +00:00
Offences report system rework (#13425)
* Experiments with common equivocation trait * Improved equivocation trait * Fix grandpa equivocation implementation * Remove some cruft * Remove some more cruft * More generic naming * Simplification of offences manipilation * More refactory * Some prograss with the encapsulation of offence report system * Finally unit type works as a universal null report system * Align substrate node code * Further simplification * Fix test utils * Remove not required associated type * Fix benches * Rollback to prev field name * Box big params * Fix typo * Remove new tag computation * Remove default implementations * Better docs * Return 'Result' instead of bool * Change offence report system return types * Some renaming and documentation * Improve documentation * More abstract offence report system * Rename 'consume_evidence' to 'process_evidence' * Further docs refinements * Doc for dummy offence report * Fix rustdoc * Fix after master merge * Apply code review suggestions * Improve docs
This commit is contained in:
Davide Galassi
@@ -35,153 +35,25 @@
|
||||
//! that the `ValidateUnsigned` for the GRANDPA pallet is used in the runtime
|
||||
//! definition.
|
||||
|
||||
use sp_std::prelude::*;
|
||||
|
||||
use codec::{self as codec, Decode, Encode};
|
||||
use frame_support::traits::{Get, KeyOwnerProofSystem};
|
||||
use sp_consensus_grandpa::{EquivocationProof, RoundNumber, SetId};
|
||||
use log::{error, info};
|
||||
use sp_consensus_grandpa::{AuthorityId, EquivocationProof, RoundNumber, SetId, KEY_TYPE};
|
||||
use sp_runtime::{
|
||||
transaction_validity::{
|
||||
InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
|
||||
TransactionValidityError, ValidTransaction,
|
||||
},
|
||||
DispatchResult, Perbill,
|
||||
DispatchError, KeyTypeId, Perbill,
|
||||
};
|
||||
use sp_session::{GetSessionNumber, GetValidatorCount};
|
||||
use sp_staking::{
|
||||
offence::{Kind, Offence, OffenceError, ReportOffence},
|
||||
offence::{Kind, Offence, OffenceReportSystem, ReportOffence},
|
||||
SessionIndex,
|
||||
};
|
||||
use sp_std::prelude::*;
|
||||
|
||||
use super::{Call, Config, Pallet, LOG_TARGET};
|
||||
|
||||
/// A trait with utility methods for handling equivocation reports in GRANDPA.
|
||||
/// The offence type is generic, and the trait provides , reporting an offence
|
||||
/// triggered by a valid equivocation report, and also for creating and
|
||||
/// submitting equivocation report extrinsics (useful only in offchain context).
|
||||
pub trait HandleEquivocation<T: Config> {
|
||||
/// The offence type used for reporting offences on valid equivocation reports.
|
||||
type Offence: GrandpaOffence<T::KeyOwnerIdentification>;
|
||||
|
||||
/// The longevity, in blocks, that the equivocation report is valid for. When using the staking
|
||||
/// pallet this should be equal to the bonding duration (in blocks, not eras).
|
||||
type ReportLongevity: Get<u64>;
|
||||
|
||||
/// Report an offence proved by the given reporters.
|
||||
fn report_offence(
|
||||
reporters: Vec<T::AccountId>,
|
||||
offence: Self::Offence,
|
||||
) -> Result<(), OffenceError>;
|
||||
|
||||
/// Returns true if all of the offenders at the given time slot have already been reported.
|
||||
fn is_known_offence(
|
||||
offenders: &[T::KeyOwnerIdentification],
|
||||
time_slot: &<Self::Offence as Offence<T::KeyOwnerIdentification>>::TimeSlot,
|
||||
) -> bool;
|
||||
|
||||
/// Create and dispatch an equivocation report extrinsic.
|
||||
fn submit_unsigned_equivocation_report(
|
||||
equivocation_proof: EquivocationProof<T::Hash, T::BlockNumber>,
|
||||
key_owner_proof: T::KeyOwnerProof,
|
||||
) -> DispatchResult;
|
||||
|
||||
/// Fetch the current block author id, if defined.
|
||||
fn block_author() -> Option<T::AccountId>;
|
||||
}
|
||||
|
||||
impl<T: Config> HandleEquivocation<T> for () {
|
||||
type Offence = GrandpaEquivocationOffence<T::KeyOwnerIdentification>;
|
||||
type ReportLongevity = ();
|
||||
|
||||
fn report_offence(
|
||||
_reporters: Vec<T::AccountId>,
|
||||
_offence: GrandpaEquivocationOffence<T::KeyOwnerIdentification>,
|
||||
) -> Result<(), OffenceError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn is_known_offence(
|
||||
_offenders: &[T::KeyOwnerIdentification],
|
||||
_time_slot: &GrandpaTimeSlot,
|
||||
) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn submit_unsigned_equivocation_report(
|
||||
_equivocation_proof: EquivocationProof<T::Hash, T::BlockNumber>,
|
||||
_key_owner_proof: T::KeyOwnerProof,
|
||||
) -> DispatchResult {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn block_author() -> Option<T::AccountId> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Generic equivocation handler. This type implements `HandleEquivocation`
|
||||
/// using existing subsystems that are part of frame (type bounds described
|
||||
/// below) and will dispatch to them directly, it's only purpose is to wire all
|
||||
/// subsystems together.
|
||||
pub struct EquivocationHandler<I, R, L, O = GrandpaEquivocationOffence<I>> {
|
||||
_phantom: sp_std::marker::PhantomData<(I, R, L, O)>,
|
||||
}
|
||||
|
||||
impl<I, R, L, O> Default for EquivocationHandler<I, R, L, O> {
|
||||
fn default() -> Self {
|
||||
Self { _phantom: Default::default() }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, R, L, O> HandleEquivocation<T> for EquivocationHandler<T::KeyOwnerIdentification, R, L, O>
|
||||
where
|
||||
// We use the authorship pallet to fetch the current block author and use
|
||||
// `offchain::SendTransactionTypes` for unsigned extrinsic creation and
|
||||
// submission.
|
||||
T: Config + pallet_authorship::Config + frame_system::offchain::SendTransactionTypes<Call<T>>,
|
||||
// A system for reporting offences after valid equivocation reports are
|
||||
// processed.
|
||||
R: ReportOffence<T::AccountId, T::KeyOwnerIdentification, O>,
|
||||
// The longevity (in blocks) that the equivocation report is valid for. When using the staking
|
||||
// pallet this should be the bonding duration.
|
||||
L: Get<u64>,
|
||||
// The offence type that should be used when reporting.
|
||||
O: GrandpaOffence<T::KeyOwnerIdentification>,
|
||||
{
|
||||
type Offence = O;
|
||||
type ReportLongevity = L;
|
||||
|
||||
fn report_offence(reporters: Vec<T::AccountId>, offence: O) -> Result<(), OffenceError> {
|
||||
R::report_offence(reporters, offence)
|
||||
}
|
||||
|
||||
fn is_known_offence(offenders: &[T::KeyOwnerIdentification], time_slot: &O::TimeSlot) -> bool {
|
||||
R::is_known_offence(offenders, time_slot)
|
||||
}
|
||||
|
||||
fn submit_unsigned_equivocation_report(
|
||||
equivocation_proof: EquivocationProof<T::Hash, T::BlockNumber>,
|
||||
key_owner_proof: T::KeyOwnerProof,
|
||||
) -> DispatchResult {
|
||||
use frame_system::offchain::SubmitTransaction;
|
||||
|
||||
let call = Call::report_equivocation_unsigned {
|
||||
equivocation_proof: Box::new(equivocation_proof),
|
||||
key_owner_proof,
|
||||
};
|
||||
|
||||
match SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into()) {
|
||||
Ok(()) => log::info!(target: LOG_TARGET, "Submitted GRANDPA equivocation report.",),
|
||||
Err(e) =>
|
||||
log::error!(target: LOG_TARGET, "Error submitting equivocation report: {:?}", e,),
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn block_author() -> Option<T::AccountId> {
|
||||
<pallet_authorship::Pallet<T>>::author()
|
||||
}
|
||||
}
|
||||
use super::{Call, Config, Error, Pallet, LOG_TARGET};
|
||||
|
||||
/// A round number and set id which point on the time of an offence.
|
||||
#[derive(Copy, Clone, PartialOrd, Ord, Eq, PartialEq, Encode, Decode)]
|
||||
@@ -193,6 +65,175 @@ pub struct GrandpaTimeSlot {
|
||||
pub round: RoundNumber,
|
||||
}
|
||||
|
||||
/// A GRANDPA equivocation offence report.
|
||||
pub struct EquivocationOffence<Offender> {
|
||||
/// Time slot at which this incident happened.
|
||||
pub time_slot: GrandpaTimeSlot,
|
||||
/// The session index in which the incident happened.
|
||||
pub session_index: SessionIndex,
|
||||
/// The size of the validator set at the time of the offence.
|
||||
pub validator_set_count: u32,
|
||||
/// The authority which produced this equivocation.
|
||||
pub offender: Offender,
|
||||
}
|
||||
|
||||
impl<Offender: Clone> Offence<Offender> for EquivocationOffence<Offender> {
|
||||
const ID: Kind = *b"grandpa:equivoca";
|
||||
type TimeSlot = GrandpaTimeSlot;
|
||||
|
||||
fn offenders(&self) -> Vec<Offender> {
|
||||
vec![self.offender.clone()]
|
||||
}
|
||||
|
||||
fn session_index(&self) -> SessionIndex {
|
||||
self.session_index
|
||||
}
|
||||
|
||||
fn validator_set_count(&self) -> u32 {
|
||||
self.validator_set_count
|
||||
}
|
||||
|
||||
fn time_slot(&self) -> Self::TimeSlot {
|
||||
self.time_slot
|
||||
}
|
||||
|
||||
// The formula is min((3k / n)^2, 1)
|
||||
// where k = offenders_number and n = validators_number
|
||||
fn slash_fraction(&self, offenders_count: u32) -> Perbill {
|
||||
// Perbill type domain is [0, 1] by definition
|
||||
Perbill::from_rational(3 * offenders_count, self.validator_set_count).square()
|
||||
}
|
||||
}
|
||||
|
||||
/// Generic equivocation handler. This type implements `HandleEquivocation`
|
||||
/// using existing subsystems that are part of frame (type bounds described
|
||||
/// below) and will dispatch to them directly, it's only purpose is to wire all
|
||||
/// subsystems together.
|
||||
pub struct EquivocationReportSystem<T, R, P, L>(sp_std::marker::PhantomData<(T, R, P, L)>);
|
||||
|
||||
// We use the authorship pallet to fetch the current block author and use
|
||||
// `offchain::SendTransactionTypes` for unsigned extrinsic creation and
|
||||
// submission.
|
||||
impl<T, R, P, L>
|
||||
OffenceReportSystem<
|
||||
Option<T::AccountId>,
|
||||
(EquivocationProof<T::Hash, T::BlockNumber>, T::KeyOwnerProof),
|
||||
> for EquivocationReportSystem<T, R, P, L>
|
||||
where
|
||||
T: Config + pallet_authorship::Config + frame_system::offchain::SendTransactionTypes<Call<T>>,
|
||||
R: ReportOffence<
|
||||
T::AccountId,
|
||||
P::IdentificationTuple,
|
||||
EquivocationOffence<P::IdentificationTuple>,
|
||||
>,
|
||||
P: KeyOwnerProofSystem<(KeyTypeId, AuthorityId), Proof = T::KeyOwnerProof>,
|
||||
P::IdentificationTuple: Clone,
|
||||
L: Get<u64>,
|
||||
{
|
||||
type Longevity = L;
|
||||
|
||||
fn publish_evidence(
|
||||
evidence: (EquivocationProof<T::Hash, T::BlockNumber>, T::KeyOwnerProof),
|
||||
) -> Result<(), ()> {
|
||||
use frame_system::offchain::SubmitTransaction;
|
||||
let (equivocation_proof, key_owner_proof) = evidence;
|
||||
|
||||
let call = Call::report_equivocation_unsigned {
|
||||
equivocation_proof: Box::new(equivocation_proof),
|
||||
key_owner_proof,
|
||||
};
|
||||
let res = SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into());
|
||||
match res {
|
||||
Ok(()) => info!(target: LOG_TARGET, "Submitted equivocation report."),
|
||||
Err(e) => error!(target: LOG_TARGET, "Error submitting equivocation report: {:?}", e),
|
||||
}
|
||||
res
|
||||
}
|
||||
|
||||
fn check_evidence(
|
||||
evidence: (EquivocationProof<T::Hash, T::BlockNumber>, T::KeyOwnerProof),
|
||||
) -> Result<(), TransactionValidityError> {
|
||||
let (equivocation_proof, key_owner_proof) = evidence;
|
||||
|
||||
// Check the membership proof to extract the offender's id
|
||||
let key = (KEY_TYPE, equivocation_proof.offender().clone());
|
||||
let offender = P::check_proof(key, key_owner_proof).ok_or(InvalidTransaction::BadProof)?;
|
||||
|
||||
// Check if the offence has already been reported, and if so then we can discard the report.
|
||||
let time_slot = GrandpaTimeSlot {
|
||||
set_id: equivocation_proof.set_id(),
|
||||
round: equivocation_proof.round(),
|
||||
};
|
||||
if R::is_known_offence(&[offender], &time_slot) {
|
||||
Err(InvalidTransaction::Stale.into())
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn process_evidence(
|
||||
reporter: Option<T::AccountId>,
|
||||
evidence: (EquivocationProof<T::Hash, T::BlockNumber>, T::KeyOwnerProof),
|
||||
) -> Result<(), DispatchError> {
|
||||
let (equivocation_proof, key_owner_proof) = evidence;
|
||||
let reporter = reporter.or_else(|| <pallet_authorship::Pallet<T>>::author());
|
||||
let offender = equivocation_proof.offender().clone();
|
||||
|
||||
// We check the equivocation within the context of its set id (and
|
||||
// associated session) and round. We also need to know the validator
|
||||
// set count when the offence since it is required to calculate the
|
||||
// slash amount.
|
||||
let set_id = equivocation_proof.set_id();
|
||||
let round = equivocation_proof.round();
|
||||
let session_index = key_owner_proof.session();
|
||||
let validator_set_count = key_owner_proof.validator_count();
|
||||
|
||||
// Validate equivocation proof (check votes are different and signatures are valid).
|
||||
if !sp_consensus_grandpa::check_equivocation_proof(equivocation_proof) {
|
||||
return Err(Error::<T>::InvalidEquivocationProof.into())
|
||||
}
|
||||
|
||||
// Validate the key ownership proof extracting the id of the offender.
|
||||
let offender = P::check_proof((KEY_TYPE, offender), key_owner_proof)
|
||||
.ok_or(Error::<T>::InvalidKeyOwnershipProof)?;
|
||||
|
||||
// Fetch the current and previous sets last session index.
|
||||
// For genesis set there's no previous set.
|
||||
let previous_set_id_session_index = if set_id != 0 {
|
||||
let idx = crate::SetIdSession::<T>::get(set_id - 1)
|
||||
.ok_or(Error::<T>::InvalidEquivocationProof)?;
|
||||
Some(idx)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let set_id_session_index =
|
||||
crate::SetIdSession::<T>::get(set_id).ok_or(Error::<T>::InvalidEquivocationProof)?;
|
||||
|
||||
// Check that the session id for the membership proof is within the
|
||||
// bounds of the set id reported in the equivocation.
|
||||
if session_index > set_id_session_index ||
|
||||
previous_set_id_session_index
|
||||
.map(|previous_index| session_index <= previous_index)
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Err(Error::<T>::InvalidEquivocationProof.into())
|
||||
}
|
||||
|
||||
let offence = EquivocationOffence {
|
||||
time_slot: GrandpaTimeSlot { set_id, round },
|
||||
session_index,
|
||||
offender,
|
||||
validator_set_count,
|
||||
};
|
||||
|
||||
R::report_offence(reporter.into_iter().collect(), offence)
|
||||
.map_err(|_| Error::<T>::DuplicateOffenceReport)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Methods for the `ValidateUnsigned` implementation:
|
||||
/// It restricts calls to `report_equivocation_unsigned` to local calls (i.e. extrinsics generated
|
||||
/// on this node) or that already in a block. This guarantees that only block authors can include
|
||||
@@ -213,11 +254,12 @@ impl<T: Config> Pallet<T> {
|
||||
},
|
||||
}
|
||||
|
||||
// check report staleness
|
||||
is_known_offence::<T>(equivocation_proof, key_owner_proof)?;
|
||||
// Check report validity
|
||||
let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
|
||||
T::EquivocationReportSystem::check_evidence(evidence)?;
|
||||
|
||||
let longevity =
|
||||
<T::HandleEquivocation as HandleEquivocation<T>>::ReportLongevity::get();
|
||||
<T::EquivocationReportSystem as OffenceReportSystem<_, _>>::Longevity::get();
|
||||
|
||||
ValidTransaction::with_tag_prefix("GrandpaEquivocation")
|
||||
// We assign the maximum priority for any equivocation report.
|
||||
@@ -239,118 +281,10 @@ impl<T: Config> Pallet<T> {
|
||||
|
||||
pub fn pre_dispatch(call: &Call<T>) -> Result<(), TransactionValidityError> {
|
||||
if let Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } = call {
|
||||
is_known_offence::<T>(equivocation_proof, key_owner_proof)
|
||||
let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
|
||||
T::EquivocationReportSystem::check_evidence(evidence)
|
||||
} else {
|
||||
Err(InvalidTransaction::Call.into())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_known_offence<T: Config>(
|
||||
equivocation_proof: &EquivocationProof<T::Hash, T::BlockNumber>,
|
||||
key_owner_proof: &T::KeyOwnerProof,
|
||||
) -> Result<(), TransactionValidityError> {
|
||||
// check the membership proof to extract the offender's id
|
||||
let key = (sp_consensus_grandpa::KEY_TYPE, equivocation_proof.offender().clone());
|
||||
|
||||
let offender = T::KeyOwnerProofSystem::check_proof(key, key_owner_proof.clone())
|
||||
.ok_or(InvalidTransaction::BadProof)?;
|
||||
|
||||
// check if the offence has already been reported,
|
||||
// and if so then we can discard the report.
|
||||
let time_slot = <T::HandleEquivocation as HandleEquivocation<T>>::Offence::new_time_slot(
|
||||
equivocation_proof.set_id(),
|
||||
equivocation_proof.round(),
|
||||
);
|
||||
|
||||
let is_known_offence = T::HandleEquivocation::is_known_offence(&[offender], &time_slot);
|
||||
|
||||
if is_known_offence {
|
||||
Err(InvalidTransaction::Stale.into())
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// A grandpa equivocation offence report.
|
||||
#[allow(dead_code)]
|
||||
pub struct GrandpaEquivocationOffence<FullIdentification> {
|
||||
/// Time slot at which this incident happened.
|
||||
pub time_slot: GrandpaTimeSlot,
|
||||
/// The session index in which the incident happened.
|
||||
pub session_index: SessionIndex,
|
||||
/// The size of the validator set at the time of the offence.
|
||||
pub validator_set_count: u32,
|
||||
/// The authority which produced this equivocation.
|
||||
pub offender: FullIdentification,
|
||||
}
|
||||
|
||||
/// An interface for types that will be used as GRANDPA offences and must also
|
||||
/// implement the `Offence` trait. This trait provides a constructor that is
|
||||
/// provided all available data during processing of GRANDPA equivocations.
|
||||
pub trait GrandpaOffence<FullIdentification>: Offence<FullIdentification> {
|
||||
/// Create a new GRANDPA offence using the given equivocation details.
|
||||
fn new(
|
||||
session_index: SessionIndex,
|
||||
validator_set_count: u32,
|
||||
offender: FullIdentification,
|
||||
set_id: SetId,
|
||||
round: RoundNumber,
|
||||
) -> Self;
|
||||
|
||||
/// Create a new GRANDPA offence time slot.
|
||||
fn new_time_slot(set_id: SetId, round: RoundNumber) -> Self::TimeSlot;
|
||||
}
|
||||
|
||||
impl<FullIdentification: Clone> GrandpaOffence<FullIdentification>
|
||||
for GrandpaEquivocationOffence<FullIdentification>
|
||||
{
|
||||
fn new(
|
||||
session_index: SessionIndex,
|
||||
validator_set_count: u32,
|
||||
offender: FullIdentification,
|
||||
set_id: SetId,
|
||||
round: RoundNumber,
|
||||
) -> Self {
|
||||
GrandpaEquivocationOffence {
|
||||
session_index,
|
||||
validator_set_count,
|
||||
offender,
|
||||
time_slot: GrandpaTimeSlot { set_id, round },
|
||||
}
|
||||
}
|
||||
|
||||
fn new_time_slot(set_id: SetId, round: RoundNumber) -> Self::TimeSlot {
|
||||
GrandpaTimeSlot { set_id, round }
|
||||
}
|
||||
}
|
||||
|
||||
impl<FullIdentification: Clone> Offence<FullIdentification>
|
||||
for GrandpaEquivocationOffence<FullIdentification>
|
||||
{
|
||||
const ID: Kind = *b"grandpa:equivoca";
|
||||
type TimeSlot = GrandpaTimeSlot;
|
||||
|
||||
fn offenders(&self) -> Vec<FullIdentification> {
|
||||
vec![self.offender.clone()]
|
||||
}
|
||||
|
||||
fn session_index(&self) -> SessionIndex {
|
||||
self.session_index
|
||||
}
|
||||
|
||||
fn validator_set_count(&self) -> u32 {
|
||||
self.validator_set_count
|
||||
}
|
||||
|
||||
fn time_slot(&self) -> Self::TimeSlot {
|
||||
self.time_slot
|
||||
}
|
||||
|
||||
fn slash_fraction(&self, offenders_count: u32) -> Perbill {
|
||||
// the formula is min((3k / n)^2, 1)
|
||||
let x = Perbill::from_rational(3 * offenders_count, self.validator_set_count);
|
||||
// _ ^ 2
|
||||
x.square()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -28,29 +28,29 @@
|
||||
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
// re-export since this is necessary for `impl_apis` in runtime.
|
||||
pub use sp_consensus_grandpa as fg_primitives;
|
||||
|
||||
use sp_std::prelude::*;
|
||||
// Re-export since this is necessary for `impl_apis` in runtime.
|
||||
pub use sp_consensus_grandpa::{
|
||||
self as fg_primitives, AuthorityId, AuthorityList, AuthorityWeight, VersionedAuthorityList,
|
||||
};
|
||||
|
||||
use codec::{self as codec, Decode, Encode, MaxEncodedLen};
|
||||
pub use fg_primitives::{AuthorityId, AuthorityList, AuthorityWeight, VersionedAuthorityList};
|
||||
use fg_primitives::{
|
||||
ConsensusLog, EquivocationProof, ScheduledChange, SetId, GRANDPA_AUTHORITIES_KEY,
|
||||
GRANDPA_ENGINE_ID, RUNTIME_LOG_TARGET as LOG_TARGET,
|
||||
};
|
||||
use frame_support::{
|
||||
dispatch::{DispatchResultWithPostInfo, Pays},
|
||||
pallet_prelude::Get,
|
||||
storage,
|
||||
traits::{KeyOwnerProofSystem, OneSessionHandler},
|
||||
traits::OneSessionHandler,
|
||||
weights::Weight,
|
||||
WeakBoundedVec,
|
||||
};
|
||||
use scale_info::TypeInfo;
|
||||
use sp_runtime::{generic::DigestItem, traits::Zero, DispatchResult, KeyTypeId};
|
||||
use sp_consensus_grandpa::{
|
||||
ConsensusLog, EquivocationProof, ScheduledChange, SetId, GRANDPA_AUTHORITIES_KEY,
|
||||
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::SessionIndex;
|
||||
use sp_staking::{offence::OffenceReportSystem, SessionIndex};
|
||||
use sp_std::prelude::*;
|
||||
|
||||
mod default_weights;
|
||||
mod equivocation;
|
||||
@@ -63,10 +63,7 @@ mod mock;
|
||||
#[cfg(all(feature = "std", test))]
|
||||
mod tests;
|
||||
|
||||
pub use equivocation::{
|
||||
EquivocationHandler, GrandpaEquivocationOffence, GrandpaOffence, GrandpaTimeSlot,
|
||||
HandleEquivocation,
|
||||
};
|
||||
pub use equivocation::{EquivocationOffence, EquivocationReportSystem, GrandpaTimeSlot};
|
||||
|
||||
pub use pallet::*;
|
||||
|
||||
@@ -91,30 +88,6 @@ pub mod pallet {
|
||||
+ Into<<Self as frame_system::Config>::RuntimeEvent>
|
||||
+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
|
||||
|
||||
/// The proof of key ownership, used for validating equivocation reports
|
||||
/// The proof must include the session index and validator count of the
|
||||
/// session at which the equivocation occurred.
|
||||
type KeyOwnerProof: Parameter + GetSessionNumber + GetValidatorCount;
|
||||
|
||||
/// The identification of a key owner, used when reporting equivocations.
|
||||
type KeyOwnerIdentification: Parameter;
|
||||
|
||||
/// A system for proving ownership of keys, i.e. that a given key was part
|
||||
/// of a validator set, needed for validating equivocation reports.
|
||||
type KeyOwnerProofSystem: KeyOwnerProofSystem<
|
||||
(KeyTypeId, AuthorityId),
|
||||
Proof = Self::KeyOwnerProof,
|
||||
IdentificationTuple = Self::KeyOwnerIdentification,
|
||||
>;
|
||||
|
||||
/// The equivocation handling subsystem, defines methods to report an
|
||||
/// offence (after the equivocation has been validated) and for submitting a
|
||||
/// transaction to report an equivocation (from an offchain context).
|
||||
/// NOTE: when enabling equivocation handling (i.e. this type isn't set to
|
||||
/// `()`) you must use this pallet's `ValidateUnsigned` in the runtime
|
||||
/// definition.
|
||||
type HandleEquivocation: HandleEquivocation<Self>;
|
||||
|
||||
/// Weights for this pallet.
|
||||
type WeightInfo: WeightInfo;
|
||||
|
||||
@@ -130,6 +103,19 @@ pub mod pallet {
|
||||
/// 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, Self::BlockNumber>, Self::KeyOwnerProof),
|
||||
>;
|
||||
}
|
||||
|
||||
#[pallet::hooks]
|
||||
@@ -211,7 +197,12 @@ pub mod pallet {
|
||||
) -> DispatchResultWithPostInfo {
|
||||
let reporter = ensure_signed(origin)?;
|
||||
|
||||
Self::do_report_equivocation(Some(reporter), *equivocation_proof, key_owner_proof)
|
||||
T::EquivocationReportSystem::process_evidence(
|
||||
Some(reporter),
|
||||
(*equivocation_proof, key_owner_proof),
|
||||
)?;
|
||||
// Waive the fee since the report is valid and beneficial
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
|
||||
/// Report voter equivocation/misbehavior. This method will verify the
|
||||
@@ -232,11 +223,11 @@ pub mod pallet {
|
||||
) -> DispatchResultWithPostInfo {
|
||||
ensure_none(origin)?;
|
||||
|
||||
Self::do_report_equivocation(
|
||||
T::HandleEquivocation::block_author(),
|
||||
*equivocation_proof,
|
||||
key_owner_proof,
|
||||
)
|
||||
T::EquivocationReportSystem::process_evidence(
|
||||
None,
|
||||
(*equivocation_proof, key_owner_proof),
|
||||
)?;
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
|
||||
/// Note that the current authority set of the GRANDPA finality gadget has stalled.
|
||||
@@ -352,7 +343,7 @@ pub mod pallet {
|
||||
#[pallet::genesis_build]
|
||||
impl<T: Config> GenesisBuild<T> for GenesisConfig {
|
||||
fn build(&self) {
|
||||
CurrentSetId::<T>::put(fg_primitives::SetId::default());
|
||||
CurrentSetId::<T>::put(SetId::default());
|
||||
Pallet::<T>::initialize(&self.authorities)
|
||||
}
|
||||
}
|
||||
@@ -532,74 +523,6 @@ impl<T: Config> Pallet<T> {
|
||||
SetIdSession::<T>::insert(0, 0);
|
||||
}
|
||||
|
||||
fn do_report_equivocation(
|
||||
reporter: Option<T::AccountId>,
|
||||
equivocation_proof: EquivocationProof<T::Hash, T::BlockNumber>,
|
||||
key_owner_proof: T::KeyOwnerProof,
|
||||
) -> DispatchResultWithPostInfo {
|
||||
// we check the equivocation within the context of its set id (and
|
||||
// associated session) and round. we also need to know the validator
|
||||
// set count when the offence since it is required to calculate the
|
||||
// slash amount.
|
||||
let set_id = equivocation_proof.set_id();
|
||||
let round = equivocation_proof.round();
|
||||
let session_index = key_owner_proof.session();
|
||||
let validator_count = key_owner_proof.validator_count();
|
||||
|
||||
// validate the key ownership proof extracting the id of the offender.
|
||||
let offender = T::KeyOwnerProofSystem::check_proof(
|
||||
(fg_primitives::KEY_TYPE, equivocation_proof.offender().clone()),
|
||||
key_owner_proof,
|
||||
)
|
||||
.ok_or(Error::<T>::InvalidKeyOwnershipProof)?;
|
||||
|
||||
// validate equivocation proof (check votes are different and
|
||||
// signatures are valid).
|
||||
if !sp_consensus_grandpa::check_equivocation_proof(equivocation_proof) {
|
||||
return Err(Error::<T>::InvalidEquivocationProof.into())
|
||||
}
|
||||
|
||||
// fetch the current and previous sets last session index. on the
|
||||
// genesis set there's no previous set.
|
||||
let previous_set_id_session_index = if set_id == 0 {
|
||||
None
|
||||
} else {
|
||||
let session_index =
|
||||
Self::session_for_set(set_id - 1).ok_or(Error::<T>::InvalidEquivocationProof)?;
|
||||
|
||||
Some(session_index)
|
||||
};
|
||||
|
||||
let set_id_session_index =
|
||||
Self::session_for_set(set_id).ok_or(Error::<T>::InvalidEquivocationProof)?;
|
||||
|
||||
// check that the session id for the membership proof is within the
|
||||
// bounds of the set id reported in the equivocation.
|
||||
if session_index > set_id_session_index ||
|
||||
previous_set_id_session_index
|
||||
.map(|previous_index| session_index <= previous_index)
|
||||
.unwrap_or(false)
|
||||
{
|
||||
return Err(Error::<T>::InvalidEquivocationProof.into())
|
||||
}
|
||||
|
||||
// report to the offences module rewarding the sender.
|
||||
T::HandleEquivocation::report_offence(
|
||||
reporter.into_iter().collect(),
|
||||
<T::HandleEquivocation as HandleEquivocation<T>>::Offence::new(
|
||||
session_index,
|
||||
validator_count,
|
||||
offender,
|
||||
set_id,
|
||||
round,
|
||||
),
|
||||
)
|
||||
.map_err(|_| Error::<T>::DuplicateOffenceReport)?;
|
||||
|
||||
// waive the fee since the report is valid and beneficial
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
|
||||
/// 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
|
||||
@@ -608,11 +531,7 @@ impl<T: Config> Pallet<T> {
|
||||
equivocation_proof: EquivocationProof<T::Hash, T::BlockNumber>,
|
||||
key_owner_proof: T::KeyOwnerProof,
|
||||
) -> Option<()> {
|
||||
T::HandleEquivocation::submit_unsigned_equivocation_report(
|
||||
equivocation_proof,
|
||||
key_owner_proof,
|
||||
)
|
||||
.ok()
|
||||
T::EquivocationReportSystem::publish_evidence((equivocation_proof, key_owner_proof)).ok()
|
||||
}
|
||||
|
||||
fn on_stalled(further_wait: T::BlockNumber, median: T::BlockNumber) {
|
||||
|
||||
@@ -225,22 +225,14 @@ parameter_types! {
|
||||
impl Config for Test {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
|
||||
type KeyOwnerProofSystem = Historical;
|
||||
|
||||
type KeyOwnerProof =
|
||||
<Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, AuthorityId)>>::Proof;
|
||||
|
||||
type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
|
||||
KeyTypeId,
|
||||
AuthorityId,
|
||||
)>>::IdentificationTuple;
|
||||
|
||||
type HandleEquivocation =
|
||||
super::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;
|
||||
|
||||
type WeightInfo = ();
|
||||
type MaxAuthorities = ConstU32<100>;
|
||||
type MaxSetIdSessionEntries = MaxSetIdSessionEntries;
|
||||
|
||||
type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, AuthorityId)>>::Proof;
|
||||
|
||||
type EquivocationReportSystem =
|
||||
super::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
|
||||
}
|
||||
|
||||
pub fn grandpa_log(log: ConsensusLog<u64>) -> DigestItem {
|
||||
|
||||
@@ -21,12 +21,11 @@
|
||||
|
||||
use super::{Call, Event, *};
|
||||
use crate::mock::*;
|
||||
use codec::Encode;
|
||||
use fg_primitives::ScheduledChange;
|
||||
use frame_support::{
|
||||
assert_err, assert_noop, assert_ok,
|
||||
dispatch::{GetDispatchInfo, Pays},
|
||||
traits::{Currency, OnFinalize, OneSessionHandler},
|
||||
traits::{Currency, KeyOwnerProofSystem, OnFinalize, OneSessionHandler},
|
||||
};
|
||||
use frame_system::{EventRecord, Phase};
|
||||
use sp_core::H256;
|
||||
|
||||
Reference in New Issue
Block a user