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

@@ -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"

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",

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>>,

substrate/frame/root-offences/Cargo.toml

+[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",
+]

substrate/frame/root-offences/README.md

+# 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

substrate/frame/root-offences/src/lib.rs

+// 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);
+		}
+	}
+}

substrate/frame/root-offences/src/mock.rs

+// 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
+}

substrate/frame/root-offences/src/tests.rs

+// 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);
+	})
+}