#![cfg_attr(not(feature = "std"), no_std)]
mod mock;
mod tests;
use sp_std::vec::Vec;
use frame_support::{
decl_module, decl_event, decl_storage, Parameter, debug,
traits::Get,
weights::Weight,
};
use sp_runtime::{traits::{Hash, Zero}, Perbill};
use sp_staking::{
SessionIndex,
offence::{Offence, ReportOffence, Kind, OnOffenceHandler, OffenceDetails, OffenceError},
};
use codec::{Encode, Decode};
type OpaqueTimeSlot = Vec<u8>;
type ReportIdOf<T> = <T as frame_system::Config>::Hash;
pub type DeferredOffenceOf<T> = (
Vec<OffenceDetails<<T as frame_system::Config>::AccountId, <T as Config>::IdentificationTuple>>,
Vec<Perbill>,
SessionIndex,
);
pub trait WeightInfo {
fn report_offence_im_online(r: u32, o: u32, n: u32, ) -> Weight;
fn report_offence_grandpa(r: u32, n: u32, ) -> Weight;
fn report_offence_babe(r: u32, n: u32, ) -> Weight;
fn on_initialize(d: u32, ) -> Weight;
}
impl WeightInfo for () {
fn report_offence_im_online(_r: u32, _o: u32, _n: u32, ) -> Weight { 1_000_000_000 }
fn report_offence_grandpa(_r: u32, _n: u32, ) -> Weight { 1_000_000_000 }
fn report_offence_babe(_r: u32, _n: u32, ) -> Weight { 1_000_000_000 }
fn on_initialize(_d: u32, ) -> Weight { 1_000_000_000 }
}
pub trait Config: frame_system::Config {
type Event: From<Event> + Into<<Self as frame_system::Config>::Event>;
type IdentificationTuple: Parameter + Ord;
type OnOffenceHandler: OnOffenceHandler<Self::AccountId, Self::IdentificationTuple, Weight>;
type WeightSoftLimit: Get<Weight>;
}
decl_storage! {
trait Store for Module<T: Config> as Offences {
Reports get(fn reports):
map hasher(twox_64_concat) ReportIdOf<T>
=> Option<OffenceDetails<T::AccountId, T::IdentificationTuple>>;
DeferredOffences get(fn deferred_offences): Vec<DeferredOffenceOf<T>>;
ConcurrentReportsIndex:
double_map hasher(twox_64_concat) Kind, hasher(twox_64_concat) OpaqueTimeSlot
=> Vec<ReportIdOf<T>>;
ReportsByKindIndex: map hasher(twox_64_concat) Kind => Vec<u8>;
}
}
decl_event!(
pub enum Event {
Offence(Kind, OpaqueTimeSlot, bool),
}
);
decl_module! {
pub struct Module<T: Config> for enum Call where origin: T::Origin {
fn deposit_event() = default;
fn on_initialize(now: T::BlockNumber) -> Weight {
if !T::OnOffenceHandler::can_report() {
return 0;
}
let limit = T::WeightSoftLimit::get();
let mut consumed = Weight::zero();
<DeferredOffences<T>>::mutate(|deferred| {
deferred.retain(|(offences, perbill, session)| {
if consumed >= limit {
true
} else {
match T::OnOffenceHandler::on_offence(&offences, &perbill, *session) {
Ok(weight) => {
consumed += weight;
false
},
Err(_) => {
debug::native::error!(
target: "pallet-offences",
"re-submitting a deferred slash returned Err at {}. This should not happen with pallet-staking",
now,
);
true
},
}
}
})
});
consumed
}
}
}
impl<T: Config, O: Offence<T::IdentificationTuple>>
ReportOffence<T::AccountId, T::IdentificationTuple, O> for Module<T>
where
T::IdentificationTuple: Clone,
{
fn report_offence(reporters: Vec<T::AccountId>, offence: O) -> Result<(), OffenceError> {
let offenders = offence.offenders();
let time_slot = offence.time_slot();
let validator_set_count = offence.validator_set_count();
let TriageOutcome { concurrent_offenders } = match Self::triage_offence_report::<O>(
reporters,
&time_slot,
offenders,
) {
Some(triage) => triage,
None => return Err(OffenceError::DuplicateReport),
};
let offenders_count = concurrent_offenders.len() as u32;
let new_fraction = O::slash_fraction(offenders_count, validator_set_count);
let slash_perbill: Vec<_> = (0..concurrent_offenders.len())
.map(|_| new_fraction.clone()).collect();
let applied = Self::report_or_store_offence(
&concurrent_offenders,
&slash_perbill,
offence.session_index(),
);
Self::deposit_event(Event::Offence(O::ID, time_slot.encode(), applied));
Ok(())
}
fn is_known_offence(offenders: &[T::IdentificationTuple], time_slot: &O::TimeSlot) -> bool {
let any_unknown = offenders.iter().any(|offender| {
let report_id = Self::report_id::<O>(time_slot, offender);
!<Reports<T>>::contains_key(&report_id)
});
!any_unknown
}
}
impl<T: Config> Module<T> {
fn report_or_store_offence(
concurrent_offenders: &[OffenceDetails<T::AccountId, T::IdentificationTuple>],
slash_perbill: &[Perbill],
session_index: SessionIndex,
) -> bool {
match T::OnOffenceHandler::on_offence(
&concurrent_offenders,
&slash_perbill,
session_index,
) {
Ok(_) => true,
Err(_) => {
<DeferredOffences<T>>::mutate(|d|
d.push((concurrent_offenders.to_vec(), slash_perbill.to_vec(), session_index))
);
false
}
}
}
fn report_id<O: Offence<T::IdentificationTuple>>(
time_slot: &O::TimeSlot,
offender: &T::IdentificationTuple,
) -> ReportIdOf<T> {
(O::ID, time_slot.encode(), offender).using_encoded(T::Hashing::hash)
}
fn triage_offence_report<O: Offence<T::IdentificationTuple>>(
reporters: Vec<T::AccountId>,
time_slot: &O::TimeSlot,
offenders: Vec<T::IdentificationTuple>,
) -> Option<TriageOutcome<T>> {
let mut storage = ReportIndexStorage::<T, O>::load(time_slot);
let mut any_new = false;
for offender in offenders {
let report_id = Self::report_id::<O>(time_slot, &offender);
if !<Reports<T>>::contains_key(&report_id) {
any_new = true;
<Reports<T>>::insert(
&report_id,
OffenceDetails {
offender,
reporters: reporters.clone(),
},
);
storage.insert(time_slot, report_id);
}
}
if any_new {
let concurrent_offenders = storage.concurrent_reports
.iter()
.filter_map(|report_id| <Reports<T>>::get(report_id))
.collect::<Vec<_>>();
storage.save();
Some(TriageOutcome {
concurrent_offenders,
})
} else {
None
}
}
#[cfg(feature = "runtime-benchmarks")]
pub fn set_deferred_offences(offences: Vec<DeferredOffenceOf<T>>) {
<DeferredOffences<T>>::put(offences);
}
}
struct TriageOutcome<T: Config> {
concurrent_offenders: Vec<OffenceDetails<T::AccountId, T::IdentificationTuple>>,
}
#[must_use = "The changes are not saved without called `save`"]
struct ReportIndexStorage<T: Config, O: Offence<T::IdentificationTuple>> {
opaque_time_slot: OpaqueTimeSlot,
concurrent_reports: Vec<ReportIdOf<T>>,
same_kind_reports: Vec<(O::TimeSlot, ReportIdOf<T>)>,
}
impl<T: Config, O: Offence<T::IdentificationTuple>> ReportIndexStorage<T, O> {
fn load(time_slot: &O::TimeSlot) -> Self {
let opaque_time_slot = time_slot.encode();
let same_kind_reports = <ReportsByKindIndex>::get(&O::ID);
let same_kind_reports =
Vec::<(O::TimeSlot, ReportIdOf<T>)>::decode(&mut &same_kind_reports[..])
.unwrap_or_default();
let concurrent_reports = <ConcurrentReportsIndex<T>>::get(&O::ID, &opaque_time_slot);
Self {
opaque_time_slot,
concurrent_reports,
same_kind_reports,
}
}
fn insert(&mut self, time_slot: &O::TimeSlot, report_id: ReportIdOf<T>) {
let pos = match self
.same_kind_reports
.binary_search_by_key(&time_slot, |&(ref when, _)| when)
{
Ok(pos) => pos,
Err(pos) => pos,
};
self.same_kind_reports
.insert(pos, (time_slot.clone(), report_id));
self.concurrent_reports.push(report_id);
}
fn save(self) {
<ReportsByKindIndex>::insert(&O::ID, self.same_kind_reports.encode());
<ConcurrentReportsIndex<T>>::insert(
&O::ID,
&self.opaque_time_slot,
&self.concurrent_reports,
);
}
}