External operator slashes info pallet

Cargo.toml

@@ -60,6 +60,7 @@ pallet-collator-assignment-runtime-api = { path = "pallets/collator-assignment/r
 pallet-configuration = { path = "pallets/configuration", default-features = false }
 pallet-data-preservers = { path = "pallets/data-preservers", default-features = false }
 pallet-data-preservers-runtime-api = { path = "pallets/data-preservers/runtime-api", default-features = false }
+pallet-external-validator-slashes = { path = "pallets/external-validator-slashes", default-features = false }
 pallet-external-validators = { path = "pallets/external-validators", default-features = false }
 pallet-inflation-rewards = { path = "pallets/inflation-rewards", default-features = false }
 pallet-initializer = { path = "pallets/initializer", default-features = false }
@@ -325,6 +326,7 @@ fc-storage = { git = "https://github.com/moondance-labs/frontier", branch = "tan
 
 # General (wasm)
 bounded-collections = { version = "0.1.8", default-features = false }
+finality-grandpa = { version = "0.16.2", default-features = false }
 hex-literal = { version = "0.3.4" }
 impl-trait-for-tuples = "0.2.2"
 impls = "1.0.3"

pallets/external-validator-slashes/Cargo.toml

@@ -0,0 +1,68 @@
+[package]
+name = "pallet-external-validator-slashes"
+authors = { workspace = true }
+description = "External validator info slashes"
+edition = "2021"
+license = "GPL-3.0-only"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = [ "x86_64-unknown-linux-gnu" ]
+
+[lints]
+workspace = true
+
+[dependencies]
+frame-benchmarking = { workspace = true, optional = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+pallet-session = { workspace = true }
+pallet-staking = { workspace = true }
+parity-scale-codec = { workspace = true, features = [ "derive", "max-encoded-len" ] }
+scale-info = { workspace = true }
+sp-runtime = { workspace = true }
+sp-staking = { workspace = true }
+sp-std = { workspace = true }
+tp-traits = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+sp-io = { workspace = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-session/std",
+	"pallet-staking/std",
+	"parity-scale-codec/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+	"tp-traits/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"scale-info/std",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+	"tp-traits/runtime-benchmarks",
+]
+
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-session/try-runtime",
+	"pallet-staking/try-runtime",
+	"sp-runtime/try-runtime",
+]

pallets/external-validator-slashes/src/benchmarking.rs

@@ -0,0 +1,95 @@
+// Copyright (C) Moondance Labs Ltd.
+// This file is part of Tanssi.
+
+// Tanssi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Tanssi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>
+
+//! Benchmarking setup for pallet-external-validator-slashes
+
+use super::*;
+
+#[allow(unused)]
+use crate::Pallet as ExternalValidatorSlashes;
+use {
+    frame_benchmarking::{v2::*, BenchmarkError},
+    frame_system::RawOrigin,
+    pallet_session::{self as session},
+    sp_runtime::traits::TrailingZeroInput,
+    sp_std::prelude::*,
+};
+
+const MAX_SLASHES: u32 = 1000;
+
+#[allow(clippy::multiple_bound_locations)]
+#[benchmarks(where T: session::Config)]
+mod benchmarks {
+    use super::*;
+
+    #[benchmark]
+    fn cancel_deferred_slash(s: Linear<1, MAX_SLASHES>) -> Result<(), BenchmarkError> {
+        let mut existing_slashes = Vec::new();
+        let era = T::EraIndexProvider::active_era().index;
+        let dummy = || T::AccountId::decode(&mut TrailingZeroInput::zeroes()).unwrap();
+        for _ in 0..MAX_SLASHES {
+            existing_slashes.push(Slash::<T::AccountId, T::SlashId>::default_from(dummy()));
+        }
+        Slashes::<T>::insert(
+            era.saturating_add(T::SlashDeferDuration::get())
+                .saturating_add(One::one()),
+            &existing_slashes,
+        );
+        let slash_indices: Vec<u32> = (0..s).collect();
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Root,
+            era.saturating_add(T::SlashDeferDuration::get())
+                .saturating_add(One::one()),
+            slash_indices,
+        );
+
+        assert_eq!(
+            Slashes::<T>::get(
+                &era.saturating_add(T::SlashDeferDuration::get())
+                    .saturating_add(One::one())
+            )
+            .len(),
+            (MAX_SLASHES - s) as usize
+        );
+        Ok(())
+    }
+
+    #[benchmark]
+    fn force_inject_slash() -> Result<(), BenchmarkError> {
+        let era = T::EraIndexProvider::active_era().index;
+        let dummy = || T::AccountId::decode(&mut TrailingZeroInput::zeroes()).unwrap();
+        #[extrinsic_call]
+        _(RawOrigin::Root, era, dummy(), Perbill::from_percent(50));
+
+        assert_eq!(
+            Slashes::<T>::get(
+                &era.saturating_add(T::SlashDeferDuration::get())
+                    .saturating_add(One::one())
+            )
+            .len(),
+            1_usize
+        );
+        Ok(())
+    }
+
+    impl_benchmark_test_suite!(
+        ExternalValidatorSlashes,
+        crate::mock::new_test_ext(),
+        crate::mock::Test,
+    );
+}