From ea43466879b767883634314fabc226ab886d3fd2 Mon Sep 17 00:00:00 2001
From: Sergej Sakac <73715684+Szegoo@users.noreply.github.com>
Date: Wed, 28 Sep 2022 22:04:14 +0200
Subject: [PATCH] New Pallet: Root offences (#11943)
* root-offences pallet
* fix errors
* cleaned up a bit
* remove unwrap()
* new pallet is getting compiled
* remove unnecessary type annotations
* remove more unnecessary type annotations
* addidtional cleaning
* commit
* cleaned up
* fix in logic
* add event
* removed Clone trait from AccountId
* test module
* remove unused imports
* fmt
* fix
* separate into functions, still messy
* test
* first test
* fmt
* cleaned up a bit
* separate into mock.rs and tests.rs
* basic docs for now
* pallet_staking GenesisiConfig
* fix
* added start_session
* passing tests
* impl GenesisConfig for pallet_session
* updated event
* Update frame/root-offences/src/lib.rs
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
* Update frame/root-offences/src/lib.rs
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
* remove <T: Config
* specifying trait bounds inside Config
* commit
* active era increases correctly :)
* ExtBuilder
* slashing works
* new test
* additional test
* commit
* order
* fix?
* fix in logic
* remove unnecessary
* wrap comment at 100
* fmt
* merge fixes
* Update frame/root-offences/src/lib.rs
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
* Update frame/root-offences/src/lib.rs
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
* docs
* Update frame/root-offences/README.md
Co-authored-by: Andronik <write@reusable.software>
* Update frame/root-offences/Cargo.toml
Co-authored-by: Andronik <write@reusable.software>
* license header
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
Co-authored-by: Andronik <write@reusable.software>
---
substrate/Cargo.lock | 22 ++
substrate/Cargo.toml | 1 +
substrate/frame/nomination-pools/src/lib.rs | 2 +-
substrate/frame/root-offences/Cargo.toml | 51 +++
substrate/frame/root-offences/README.md | 5 +
substrate/frame/root-offences/src/lib.rs | 131 +++++++
substrate/frame/root-offences/src/mock.rs | 356 ++++++++++++++++++++
substrate/frame/root-offences/src/tests.rs | 94 ++++++
8 files changed, 661 insertions(+), 1 deletion(-)
create mode 100644 substrate/frame/root-offences/Cargo.toml
create mode 100644 substrate/frame/root-offences/README.md
create mode 100644 substrate/frame/root-offences/src/lib.rs
create mode 100644 substrate/frame/root-offences/src/mock.rs
create mode 100644 substrate/frame/root-offences/src/tests.rs
diff --git a/substrate/Cargo.lock b/substrate/Cargo.lock
index a9a0eef5511..de50d4ec271 100644
--- a/substrate/Cargo.lock
+++ b/substrate/Cargo.lock
@@ -6197,6 +6197,28 @@ dependencies = [
"sp-std",
]
+[[package]]
+name = "pallet-root-offences"
+version = "1.0.0"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-offences",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+]
+
[[package]]
name = "pallet-scheduler"
version = "4.0.0-dev"
diff --git a/substrate/Cargo.toml b/substrate/Cargo.toml
index 018355df6c9..25f12a2c9fd 100644
--- a/substrate/Cargo.toml
+++ b/substrate/Cargo.toml
@@ -135,6 +135,7 @@ members = [
"frame/staking/reward-fn",
"frame/state-trie-migration",
"frame/sudo",
+ "frame/root-offences",
"frame/support",
"frame/support/procedural",
"frame/support/procedural/tools",
diff --git a/substrate/frame/nomination-pools/src/lib.rs b/substrate/frame/nomination-pools/src/lib.rs
index 28d10ce5734..9e77adaeee6 100644
--- a/substrate/frame/nomination-pools/src/lib.rs
+++ b/substrate/frame/nomination-pools/src/lib.rs
@@ -2523,7 +2523,7 @@ impl<T: Config> Pallet<T> {
impl<T: Config> OnStakerSlash<T::AccountId, BalanceOf<T>> for Pallet<T> {
fn on_slash(
pool_account: &T::AccountId,
- // Bonded balance is always read directly from staking, therefore we need not update
+ // Bonded balance is always read directly from staking, therefore we don't need to update
// anything here.
slashed_bonded: BalanceOf<T>,
slashed_unlocking: &BTreeMap<EraIndex, BalanceOf<T>>,
diff --git a/substrate/frame/root-offences/Cargo.toml b/substrate/frame/root-offences/Cargo.toml
new file mode 100644
index 00000000000..ea6a6527848
--- /dev/null
+++ b/substrate/frame/root-offences/Cargo.toml
@@ -0,0 +1,51 @@
+[package]
+name = "pallet-root-offences"
+version = "1.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME root offences pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+
+pallet-session = { version = "4.0.0-dev", features = [ "historical" ], path = "../../frame/session", default-features = false }
+pallet-staking = { version = "4.0.0-dev", default-features = false, path = "../../frame/staking" }
+pallet-offences = { version = "4.0.0-dev", default-features = false, path = "../../frame/offences" }
+
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "6.0.0", path = "../../primitives/runtime" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../timestamp" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../staking/reward-curve" }
+
+sp-core = { version = "6.0.0", path = "../../primitives/core" }
+sp-io = { version = "6.0.0", default-features = false, path = "../../primitives/io" }
+sp-std = { version = "4.0.0", default-features = false, path = "../../primitives/std" }
+
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
+
+[features]
+runtime-benchmarks = []
+try-runtime = ["frame-support/try-runtime"]
+default = ["std"]
+std = [
+ "codec/std",
+ "frame-support/std",
+ "frame-system/std",
+ "pallet-session/std",
+ "pallet-staking/std",
+ "pallet-offences/std",
+ "scale-info/std",
+ "sp-runtime/std",
+]
diff --git a/substrate/frame/root-offences/README.md b/substrate/frame/root-offences/README.md
new file mode 100644
index 00000000000..a2c5261b698
--- /dev/null
+++ b/substrate/frame/root-offences/README.md
@@ -0,0 +1,5 @@
+# Sudo Offences Pallet
+
+Pallet that allows the root to create an offence.
+
+NOTE: This pallet should only be used for testing purposes.
\ No newline at end of file
diff --git a/substrate/frame/root-offences/src/lib.rs b/substrate/frame/root-offences/src/lib.rs
new file mode 100644
index 00000000000..b4b549627f3
--- /dev/null
+++ b/substrate/frame/root-offences/src/lib.rs
@@ -0,0 +1,131 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+//! # Sudo Offences Pallet
+//! Pallet that allows the root to create an offence.
+//!
+//! NOTE: This pallet should be used for testing purposes.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+use pallet_session::historical::IdentificationTuple;
+use pallet_staking::{BalanceOf, Exposure, ExposureOf, Pallet as Staking};
+use sp_runtime::Perbill;
+use sp_staking::offence::{DisableStrategy, OnOffenceHandler};
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+ use super::*;
+ use frame_support::pallet_prelude::*;
+ use frame_system::pallet_prelude::*;
+
+ #[pallet::config]
+ pub trait Config:
+ frame_system::Config
+ + pallet_staking::Config
+ + pallet_session::Config<ValidatorId = <Self as frame_system::Config>::AccountId>
+ + pallet_session::historical::Config<
+ FullIdentification = Exposure<
+ <Self as frame_system::Config>::AccountId,
+ BalanceOf<Self>,
+ >,
+ FullIdentificationOf = ExposureOf<Self>,
+ >
+ {
+ type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+ }
+
+ #[pallet::pallet]
+ #[pallet::generate_store(pub(super) trait Store)]
+ pub struct Pallet<T>(_);
+
+ #[pallet::event]
+ #[pallet::generate_deposit(pub(super) fn deposit_event)]
+ pub enum Event<T: Config> {
+ /// An offence was created by root.
+ OffenceCreated { offenders: Vec<(T::AccountId, Perbill)> },
+ }
+
+ #[pallet::error]
+ pub enum Error<T> {
+ /// Failed to get the active era from the staking pallet.
+ FailedToGetActiveEra,
+ }
+
+ type OffenceDetails<T> = sp_staking::offence::OffenceDetails<
+ <T as frame_system::Config>::AccountId,
+ IdentificationTuple<T>,
+ >;
+
+ #[pallet::call]
+ impl<T: Config> Pallet<T> {
+ /// Allows the `root`, for example sudo to create an offence.
+ #[pallet::weight(T::DbWeight::get().reads(2))]
+ pub fn create_offence(
+ origin: OriginFor<T>,
+ offenders: Vec<(T::AccountId, Perbill)>,
+ ) -> DispatchResult {
+ ensure_root(origin)?;
+
+ let slash_fraction =
+ offenders.clone().into_iter().map(|(_, fraction)| fraction).collect::<Vec<_>>();
+ let offence_details = Self::get_offence_details(offenders.clone())?;
+
+ Self::submit_offence(&offence_details, &slash_fraction);
+ Self::deposit_event(Event::OffenceCreated { offenders });
+ Ok(())
+ }
+ }
+
+ impl<T: Config> Pallet<T> {
+ /// Returns a vector of offenders that are going to be slashed.
+ fn get_offence_details(
+ offenders: Vec<(T::AccountId, Perbill)>,
+ ) -> Result<Vec<OffenceDetails<T>>, DispatchError> {
+ let now = Staking::<T>::active_era()
+ .map(|e| e.index)
+ .ok_or(Error::<T>::FailedToGetActiveEra)?;
+
+ Ok(offenders
+ .clone()
+ .into_iter()
+ .map(|(o, _)| OffenceDetails::<T> {
+ offender: (o.clone(), Staking::<T>::eras_stakers(now, o)),
+ reporters: vec![],
+ })
+ .collect())
+ }
+
+ /// Submits the offence by calling the `on_offence` function.
+ fn submit_offence(offenders: &[OffenceDetails<T>], slash_fraction: &[Perbill]) {
+ let session_index = <pallet_session::Pallet<T> as frame_support::traits::ValidatorSet<T::AccountId>>::session_index();
+
+ <pallet_staking::Pallet<T> as OnOffenceHandler<
+ T::AccountId,
+ IdentificationTuple<T>,
+ Weight,
+ >>::on_offence(&offenders, &slash_fraction, session_index, DisableStrategy::WhenSlashed);
+ }
+ }
+}
diff --git a/substrate/frame/root-offences/src/mock.rs b/substrate/frame/root-offences/src/mock.rs
new file mode 100644
index 00000000000..3f0a26afc13
--- /dev/null
+++ b/substrate/frame/root-offences/src/mock.rs
@@ -0,0 +1,356 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+use super::*;
+use crate as root_offences;
+
+use frame_election_provider_support::{onchain, SequentialPhragmen};
+use frame_support::{
+ parameter_types,
+ traits::{ConstU32, ConstU64, GenesisBuild, Hooks, OneSessionHandler},
+};
+use pallet_staking::StakerStatus;
+use sp_core::H256;
+use sp_runtime::{
+ curve::PiecewiseLinear,
+ testing::{Header, UintAuthorityId},
+ traits::{BlakeTwo256, IdentityLookup, Zero},
+};
+use sp_staking::{EraIndex, SessionIndex};
+use sp_std::collections::btree_map::BTreeMap;
+
+type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
+type Block = frame_system::mocking::MockBlock<Test>;
+type AccountId = u64;
+type Balance = u64;
+type BlockNumber = u64;
+
+pub const INIT_TIMESTAMP: u64 = 30_000;
+pub const BLOCK_TIME: u64 = 1000;
+
+frame_support::construct_runtime!(
+ pub enum Test where
+ Block = Block,
+ NodeBlock = Block,
+ UncheckedExtrinsic = UncheckedExtrinsic,
+ {
+ System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+ Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+ Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+ Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
+ Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+ RootOffences: root_offences::{Pallet, Call, Storage, Event<T>},
+ Historical: pallet_session::historical::{Pallet, Storage},
+ }
+);
+
+/// Another session handler struct to test on_disabled.
+pub struct OtherSessionHandler;
+impl OneSessionHandler<AccountId> for OtherSessionHandler {
+ type Key = UintAuthorityId;
+
+ fn on_genesis_session<'a, I: 'a>(_: I)
+ where
+ I: Iterator<Item = (&'a AccountId, Self::Key)>,
+ AccountId: 'a,
+ {
+ }
+
+ fn on_new_session<'a, I: 'a>(_: bool, _: I, _: I)
+ where
+ I: Iterator<Item = (&'a AccountId, Self::Key)>,
+ AccountId: 'a,
+ {
+ }
+
+ fn on_disabled(_validator_index: u32) {}
+}
+
+impl sp_runtime::BoundToRuntimeAppPublic for OtherSessionHandler {
+ type Public = UintAuthorityId;
+}
+
+parameter_types! {
+ pub BlockWeights: frame_system::limits::BlockWeights =
+ frame_system::limits::BlockWeights::simple_max(frame_support::weights::Weight::from_ref_time(1024));
+}
+
+impl frame_system::Config for Test {
+ type BaseCallFilter = frame_support::traits::Everything;
+ type BlockWeights = ();
+ type BlockLength = ();
+ type DbWeight = ();
+ type RuntimeOrigin = RuntimeOrigin;
+ type Index = u64;
+ type BlockNumber = u64;
+ type Hash = H256;
+ type RuntimeCall = RuntimeCall;
+ type Hashing = BlakeTwo256;
+ type AccountId = u64;
+ type Lookup = IdentityLookup<Self::AccountId>;
+ type Header = Header;
+ type RuntimeEvent = RuntimeEvent;
+ type BlockHashCount = ConstU64<250>;
+ type Version = ();
+ type PalletInfo = PalletInfo;
+ type AccountData = pallet_balances::AccountData<u64>;
+ type OnNewAccount = ();
+ type OnKilledAccount = ();
+ type SystemWeightInfo = ();
+ type SS58Prefix = ();
+ type OnSetCode = ();
+ type MaxConsumers = ConstU32<16>;
+}
+
+impl pallet_balances::Config for Test {
+ type MaxLocks = ();
+ type MaxReserves = ();
+ type ReserveIdentifier = [u8; 8];
+ type Balance = Balance;
+ type RuntimeEvent = RuntimeEvent;
+ type DustRemoval = ();
+ type ExistentialDeposit = ConstU64<1>;
+ type AccountStore = System;
+ type WeightInfo = ();
+}
+
+pallet_staking_reward_curve::build! {
+ const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
+ min_inflation: 0_025_000u64,
+ max_inflation: 0_100_000,
+ ideal_stake: 0_500_000,
+ falloff: 0_050_000,
+ max_piece_count: 40,
+ test_precision: 0_005_000,
+ );
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+ type System = Test;
+ type Solver = SequentialPhragmen<AccountId, Perbill>;
+ type DataProvider = Staking;
+ type WeightInfo = ();
+}
+
+pub struct OnStakerSlashMock<T: Config>(core::marker::PhantomData<T>);
+impl<T: Config> sp_staking::OnStakerSlash<AccountId, Balance> for OnStakerSlashMock<T> {
+ fn on_slash(
+ _pool_account: &AccountId,
+ slashed_bonded: Balance,
+ slashed_chunks: &BTreeMap<EraIndex, Balance>,
+ ) {
+ LedgerSlashPerEra::set((slashed_bonded, slashed_chunks.clone()));
+ }
+}
+
+parameter_types! {
+ pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+ pub static Offset: BlockNumber = 0;
+ pub const Period: BlockNumber = 1;
+ pub static SessionsPerEra: SessionIndex = 3;
+ pub static SlashDeferDuration: EraIndex = 0;
+ pub const BondingDuration: EraIndex = 3;
+ pub static LedgerSlashPerEra: (BalanceOf<Test>, BTreeMap<EraIndex, BalanceOf<Test>>) = (Zero::zero(), BTreeMap::new());
+ pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(75);
+}
+
+impl pallet_staking::Config for Test {
+ type MaxNominations = ConstU32<16>;
+ type Currency = Balances;
+ type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
+ type UnixTime = Timestamp;
+ type CurrencyToVote = frame_support::traits::SaturatingCurrencyToVote;
+ type RewardRemainder = ();
+ type RuntimeEvent = RuntimeEvent;
+ type Slash = ();
+ type Reward = ();
+ type SessionsPerEra = SessionsPerEra;
+ type SlashDeferDuration = SlashDeferDuration;
+ type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
+ type BondingDuration = BondingDuration;
+ type SessionInterface = Self;
+ type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
+ type NextNewSession = Session;
+ type MaxNominatorRewardedPerValidator = ConstU32<64>;
+ type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+ type ElectionProvider = onchain::UnboundedExecution<OnChainSeqPhragmen>;
+ type GenesisElectionProvider = Self::ElectionProvider;
+ type TargetList = pallet_staking::UseValidatorsMap<Self>;
+ type MaxUnlockingChunks = ConstU32<32>;
+ type HistoryDepth = ConstU32<84>;
+ type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
+ type OnStakerSlash = OnStakerSlashMock<Test>;
+ type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+ type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Test {
+ type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
+ type FullIdentificationOf = pallet_staking::ExposureOf<Test>;
+}
+
+sp_runtime::impl_opaque_keys! {
+ pub struct SessionKeys {
+ pub other: OtherSessionHandler,
+ }
+}
+
+impl pallet_session::Config for Test {
+ type SessionManager = pallet_session::historical::NoteHistoricalRoot<Test, Staking>;
+ type Keys = SessionKeys;
+ type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+ type SessionHandler = (OtherSessionHandler,);
+ type RuntimeEvent = RuntimeEvent;
+ type ValidatorId = AccountId;
+ type ValidatorIdOf = pallet_staking::StashOf<Test>;
+ type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+ type WeightInfo = ();
+}
+
+impl pallet_timestamp::Config for Test {
+ type Moment = u64;
+ type OnTimestampSet = ();
+ type MinimumPeriod = ConstU64<5>;
+ type WeightInfo = ();
+}
+
+impl Config for Test {
+ type RuntimeEvent = RuntimeEvent;
+}
+
+pub struct ExtBuilder {
+ validator_count: u32,
+ minimum_validator_count: u32,
+ invulnerables: Vec<AccountId>,
+ balance_factor: Balance,
+}
+
+impl Default for ExtBuilder {
+ fn default() -> Self {
+ Self {
+ validator_count: 2,
+ minimum_validator_count: 0,
+ invulnerables: vec![],
+ balance_factor: 1,
+ }
+ }
+}
+
+impl ExtBuilder {
+ fn build(self) -> sp_io::TestExternalities {
+ let mut storage = frame_system::GenesisConfig::default().build_storage::<Test>().unwrap();
+
+ pallet_balances::GenesisConfig::<Test> {
+ balances: vec![
+ //controllers
+ (10, self.balance_factor * 50),
+ (20, self.balance_factor * 50),
+ (30, self.balance_factor * 50),
+ (40, self.balance_factor * 50),
+ // stashes
+ (11, self.balance_factor * 1000),
+ (21, self.balance_factor * 1000),
+ (31, self.balance_factor * 500),
+ (41, self.balance_factor * 1000),
+ ],
+ }
+ .assimilate_storage(&mut storage)
+ .unwrap();
+
+ let stakers = vec![
+ // (stash, ctrl, stake, status)
+ // these two will be elected in the default test where we elect 2.
+ (11, 10, 1000, StakerStatus::<AccountId>::Validator),
+ (21, 20, 1000, StakerStatus::<AccountId>::Validator),
+ // a loser validator
+ (31, 30, 500, StakerStatus::<AccountId>::Validator),
+ // an idle validator
+ (41, 40, 1000, StakerStatus::<AccountId>::Idle),
+ ];
+
+ let _ = pallet_staking::GenesisConfig::<Test> {
+ stakers: stakers.clone(),
+ ..Default::default()
+ };
+
+ let _ = pallet_staking::GenesisConfig::<Test> {
+ stakers: stakers.clone(),
+ validator_count: self.validator_count,
+ minimum_validator_count: self.minimum_validator_count,
+ invulnerables: self.invulnerables,
+ slash_reward_fraction: Perbill::from_percent(10),
+ ..Default::default()
+ }
+ .assimilate_storage(&mut storage);
+
+ let _ = pallet_session::GenesisConfig::<Test> {
+ keys: stakers
+ .into_iter()
+ .map(|(id, ..)| (id, id, SessionKeys { other: id.into() }))
+ .collect(),
+ }
+ .assimilate_storage(&mut storage);
+
+ storage.into()
+ }
+
+ pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+ let mut ext = self.build();
+ ext.execute_with(test);
+ }
+}
+
+/// Progresses from the current block number (whatever that may be) to the `P * session_index + 1`.
+pub(crate) fn start_session(session_index: SessionIndex) {
+ let end: u64 = if Offset::get().is_zero() {
+ (session_index as u64) * Period::get()
+ } else {
+ Offset::get() + (session_index.saturating_sub(1) as u64) * Period::get()
+ };
+ run_to_block(end);
+ // session must have progressed properly.
+ assert_eq!(
+ Session::current_index(),
+ session_index,
+ "current session index = {}, expected = {}",
+ Session::current_index(),
+ session_index,
+ );
+}
+
+/// Progress to the given block, triggering session and era changes as we progress.
+///
+/// This will finalize the previous block, initialize up to the given block, essentially simulating
+/// a block import/propose process where we first initialize the block, then execute some stuff (not
+/// in the function), and then finalize the block.
+pub(crate) fn run_to_block(n: BlockNumber) {
+ Staking::on_finalize(System::block_number());
+ for b in (System::block_number() + 1)..=n {
+ System::set_block_number(b);
+ Session::on_initialize(b);
+ <Staking as Hooks<u64>>::on_initialize(b);
+ Timestamp::set_timestamp(System::block_number() * BLOCK_TIME + INIT_TIMESTAMP);
+ if b != n {
+ Staking::on_finalize(System::block_number());
+ }
+ }
+}
+
+pub(crate) fn active_era() -> EraIndex {
+ Staking::active_era().unwrap().index
+}
diff --git a/substrate/frame/root-offences/src/tests.rs b/substrate/frame/root-offences/src/tests.rs
new file mode 100644
index 00000000000..a8b7d0a6d6a
--- /dev/null
+++ b/substrate/frame/root-offences/src/tests.rs
@@ -0,0 +1,94 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+use super::*;
+use frame_support::{assert_err, assert_ok};
+use mock::{active_era, start_session, Balances, ExtBuilder, RootOffences, RuntimeOrigin, System};
+
+#[test]
+fn create_offence_fails_given_signed_origin() {
+ use sp_runtime::traits::BadOrigin;
+ ExtBuilder::default().build_and_execute(|| {
+ let offenders = (&[]).to_vec();
+ assert_err!(RootOffences::create_offence(RuntimeOrigin::signed(1), offenders), BadOrigin);
+ })
+}
+
+#[test]
+fn create_offence_works_given_root_origin() {
+ ExtBuilder::default().build_and_execute(|| {
+ start_session(1);
+
+ assert_eq!(active_era(), 0);
+
+ assert_eq!(Balances::free_balance(11), 1000);
+
+ let offenders = [(11, Perbill::from_percent(50))].to_vec();
+ assert_ok!(RootOffences::create_offence(RuntimeOrigin::root(), offenders.clone()));
+
+ System::assert_last_event(Event::OffenceCreated { offenders }.into());
+ // the slash should be applied right away.
+ assert_eq!(Balances::free_balance(11), 500);
+
+ // the other validator should keep his balance, because we only created
+ // an offences for the first validator.
+ assert_eq!(Balances::free_balance(21), 1000);
+ })
+}
+
+#[test]
+fn create_offence_wont_slash_non_active_validators() {
+ ExtBuilder::default().build_and_execute(|| {
+ start_session(1);
+
+ assert_eq!(active_era(), 0);
+
+ // 31 is not an active validator.
+ assert_eq!(Balances::free_balance(31), 500);
+
+ let offenders = [(31, Perbill::from_percent(20)), (11, Perbill::from_percent(20))].to_vec();
+ assert_ok!(RootOffences::create_offence(RuntimeOrigin::root(), offenders.clone()));
+
+ System::assert_last_event(Event::OffenceCreated { offenders }.into());
+
+ // so 31 didn't get slashed.
+ assert_eq!(Balances::free_balance(31), 500);
+
+ // but 11 is an active validator so he got slashed.
+ assert_eq!(Balances::free_balance(11), 800);
+ })
+}
+
+#[test]
+fn create_offence_wont_slash_idle() {
+ ExtBuilder::default().build_and_execute(|| {
+ start_session(1);
+
+ assert_eq!(active_era(), 0);
+
+ // 41 is idle.
+ assert_eq!(Balances::free_balance(41), 1000);
+
+ let offenders = [(41, Perbill::from_percent(50))].to_vec();
+ assert_ok!(RootOffences::create_offence(RuntimeOrigin::root(), offenders.clone()));
+
+ System::assert_last_event(Event::OffenceCreated { offenders }.into());
+
+ // 41 didn't get slashed.
+ assert_eq!(Balances::free_balance(41), 1000);
+ })
+}
--
GitLab