diff --git a/polkadot/runtime/westend/src/weights/pallet_staking.rs b/polkadot/runtime/westend/src/weights/pallet_staking.rs
index 5a176c76b6e816b5fa5adcd1439721c53fe1e531..496bc01e5e38d03011f62b1616000621191a0321 100644
--- a/polkadot/runtime/westend/src/weights/pallet_staking.rs
+++ b/polkadot/runtime/westend/src/weights/pallet_staking.rs
@@ -875,4 +875,33 @@ impl<T: frame_system::Config> pallet_staking::WeightInfo for WeightInfo<T> {
.saturating_add(T::DbWeight::get().reads(457))
.saturating_add(T::DbWeight::get().writes(261))
}
+ /// Storage: `Staking::CurrentEra` (r:1 w:0)
+ /// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ErasStartSessionIndex` (r:1 w:0)
+ /// Proof: `Staking::ErasStartSessionIndex` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ActiveEra` (r:1 w:0)
+ /// Proof: `Staking::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::Invulnerables` (r:1 w:0)
+ /// Proof: `Staking::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ErasStakersOverview` (r:1 w:0)
+ /// Proof: `Staking::ErasStakersOverview` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+ /// Storage: `Session::DisabledValidators` (r:1 w:1)
+ /// Proof: `Session::DisabledValidators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+ /// Storage: `Session::Validators` (r:1 w:0)
+ /// Proof: `Session::Validators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+ /// Storage: `Staking::ValidatorSlashInEra` (r:1 w:1)
+ /// Proof: `Staking::ValidatorSlashInEra` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::OffenceQueue` (r:1 w:1)
+ /// Proof: `Staking::OffenceQueue` (`max_values`: None, `max_size`: Some(101), added: 2576, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::OffenceQueueEras` (r:1 w:1)
+ /// Proof: `Staking::OffenceQueueEras` (`max_values`: Some(1), `max_size`: Some(2690), added: 3185, mode: `MaxEncodedLen`)
+ fn manual_slash() -> Weight {
+ // Proof Size summary in bytes:
+ // Measured: `514`
+ // Estimated: `4175`
+ // Minimum execution time: 30_000_000 picoseconds.
+ Weight::from_parts(33_000_000, 4175)
+ .saturating_add(T::DbWeight::get().reads(10_u64))
+ .saturating_add(T::DbWeight::get().writes(4_u64))
+ }
}
diff --git a/prdoc/pr_7805.prdoc b/prdoc/pr_7805.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..1de4fcd085984144e2a60051d13cde6857aca91f
--- /dev/null
+++ b/prdoc/pr_7805.prdoc
@@ -0,0 +1,11 @@
+title: New `staking::manual_slash` extrinsic
+
+doc:
+ - audience: Runtime Dev
+ description: A new `manual_slash` extrinsic that allows slashing a validator's stake manually by governance.
+
+crates:
+ - name: pallet-staking
+ bump: major
+ - name: westend-runtime
+ bump: major
diff --git a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
index aa9b314d0068e9fc78a619cafcba8a5a638a6d38..e4b77975707c4ad894128c0f2cd98441a10b92cb 100644
--- a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
@@ -899,7 +899,7 @@ pub(crate) fn on_offence_now(
slash_fraction: &[Perbill],
) {
let now = ActiveEra::<Runtime>::get().unwrap().index;
- let _ = Staking::on_offence(
+ let _ = <Staking as OnOffenceHandler<_, _, _>>::on_offence(
offenders,
slash_fraction,
ErasStartSessionIndex::<Runtime>::get(now).unwrap(),
diff --git a/substrate/frame/staking/src/benchmarking.rs b/substrate/frame/staking/src/benchmarking.rs
index 1978449bb4ba8d1453d99b753ded280315e22175..c4299449196e61eaecb3fce379e6072a6ef16d63 100644
--- a/substrate/frame/staking/src/benchmarking.rs
+++ b/substrate/frame/staking/src/benchmarking.rs
@@ -1189,6 +1189,33 @@ mod benchmarks {
Ok(())
}
+ #[benchmark]
+ fn manual_slash() -> Result<(), BenchmarkError> {
+ let era = EraIndex::zero();
+ CurrentEra::<T>::put(era);
+ ErasStartSessionIndex::<T>::insert(era, 0);
+ ActiveEra::<T>::put(ActiveEraInfo { index: era, start: None });
+
+ // Create a validator with nominators
+ let (validator_stash, _nominators) = create_validator_with_nominators::<T>(
+ T::MaxExposurePageSize::get() as u32,
+ T::MaxExposurePageSize::get() as u32,
+ false,
+ true,
+ RewardDestination::Staked,
+ era,
+ )?;
+
+ let slash_fraction = Perbill::from_percent(10);
+
+ #[extrinsic_call]
+ _(RawOrigin::Root, validator_stash.clone(), era, slash_fraction);
+
+ assert!(ValidatorSlashInEra::<T>::get(era, &validator_stash).is_some());
+
+ Ok(())
+ }
+
impl_benchmark_test_suite!(
Staking,
crate::mock::ExtBuilder::default().has_stakers(true),
diff --git a/substrate/frame/staking/src/mock.rs b/substrate/frame/staking/src/mock.rs
index 4546dbf74594691d02a4ae1f076b83b26b044cdb..cf1b2c7912aef8ec0744cee0f120b1f1a0d5a6c4 100644
--- a/substrate/frame/staking/src/mock.rs
+++ b/substrate/frame/staking/src/mock.rs
@@ -846,7 +846,11 @@ pub(crate) fn on_offence_in_era(
let bonded_eras = crate::BondedEras::<Test>::get();
for &(bonded_era, start_session) in bonded_eras.iter() {
if bonded_era == era {
- let _ = Staking::on_offence(offenders, slash_fraction, start_session);
+ let _ = <Staking as OnOffenceHandler<_, _, _>>::on_offence(
+ offenders,
+ slash_fraction,
+ start_session,
+ );
if advance_processing_blocks {
advance_blocks(process_blocks as u64);
}
@@ -857,7 +861,7 @@ pub(crate) fn on_offence_in_era(
}
if pallet_staking::ActiveEra::<Test>::get().unwrap().index == era {
- let _ = Staking::on_offence(
+ let _ = <Staking as OnOffenceHandler<_, _, _>>::on_offence(
offenders,
slash_fraction,
pallet_staking::ErasStartSessionIndex::<Test>::get(era).unwrap(),
diff --git a/substrate/frame/staking/src/pallet/impls.rs b/substrate/frame/staking/src/pallet/impls.rs
index 0a06236238cd851a2a3ea252fae0a4ffbe816a8d..0d4ec8c16e23173cd9b41a115146ebae19167228 100644
--- a/substrate/frame/staking/src/pallet/impls.rs
+++ b/substrate/frame/staking/src/pallet/impls.rs
@@ -1833,6 +1833,24 @@ where
slash_session,
);
+ // the exposure is not actually being used in this implementation
+ let offenders = offenders.iter().map(|details| {
+ let (ref offender, _) = details.offender;
+ OffenceDetails { offender: offender.clone(), reporters: details.reporters.clone() }
+ });
+ Self::on_offence(offenders, slash_fractions, slash_session)
+ }
+}
+
+impl<T: Config> Pallet<T> {
+ /// When an offence is reported, it is split into pages and put in the offence queue.
+ /// As offence queue is processed, computed slashes are queued to be applied after the
+ /// `SlashDeferDuration`.
+ pub fn on_offence(
+ offenders: impl Iterator<Item = OffenceDetails<T::AccountId, T::AccountId>>,
+ slash_fractions: &[Perbill],
+ slash_session: SessionIndex,
+ ) -> Weight {
// todo(ank4n): Needs to be properly benched.
let mut consumed_weight = Weight::zero();
let mut add_db_reads_writes = |reads, writes| {
@@ -1876,8 +1894,8 @@ where
add_db_reads_writes(1, 0);
let invulnerables = Invulnerables::<T>::get();
- for (details, slash_fraction) in offenders.iter().zip(slash_fractions) {
- let (validator, _) = &details.offender;
+ for (details, slash_fraction) in offenders.zip(slash_fractions) {
+ let validator = &details.offender;
// Skip if the validator is invulnerable.
if invulnerables.contains(&validator) {
log!(debug, "🦹 on_offence: {:?} is invulnerable; ignoring offence", validator);
diff --git a/substrate/frame/staking/src/pallet/mod.rs b/substrate/frame/staking/src/pallet/mod.rs
index 6a6ba36d9693b55c9503c9b0ea005cb9f2de20b2..bd035bbc0f0fd917b9b06de5e4fac3b8c1790e62 100644
--- a/substrate/frame/staking/src/pallet/mod.rs
+++ b/substrate/frame/staking/src/pallet/mod.rs
@@ -2607,5 +2607,63 @@ pub mod pallet {
Ok(Pays::No.into())
}
+
+ /// This function allows governance to manually slash a validator and is a
+ /// **fallback mechanism**.
+ ///
+ /// The dispatch origin must be `T::AdminOrigin`.
+ ///
+ /// ## Parameters
+ /// - `validator_stash` - The stash account of the validator to slash.
+ /// - `era` - The era in which the validator was in the active set.
+ /// - `slash_fraction` - The percentage of the stake to slash, expressed as a Perbill.
+ ///
+ /// ## Behavior
+ ///
+ /// The slash will be applied using the standard slashing mechanics, respecting the
+ /// configured `SlashDeferDuration`.
+ ///
+ /// This means:
+ /// - If the validator was already slashed by a higher percentage for the same era, this
+ /// slash will have no additional effect.
+ /// - If the validator was previously slashed by a lower percentage, only the difference
+ /// will be applied.
+ /// - The slash will be deferred by `SlashDeferDuration` eras before being enacted.
+ #[pallet::call_index(33)]
+ #[pallet::weight(T::WeightInfo::manual_slash())]
+ pub fn manual_slash(
+ origin: OriginFor<T>,
+ validator_stash: T::AccountId,
+ era: EraIndex,
+ slash_fraction: Perbill,
+ ) -> DispatchResult {
+ T::AdminOrigin::ensure_origin(origin)?;
+
+ // Check era is valid
+ let current_era = CurrentEra::<T>::get().ok_or(Error::<T>::InvalidEraToReward)?;
+ let history_depth = T::HistoryDepth::get();
+ ensure!(
+ era <= current_era && era >= current_era.saturating_sub(history_depth),
+ Error::<T>::InvalidEraToReward
+ );
+
+ let offence_details = sp_staking::offence::OffenceDetails {
+ offender: validator_stash.clone(),
+ reporters: Vec::new(),
+ };
+
+ // Get the session index for the era
+ let session_index =
+ ErasStartSessionIndex::<T>::get(era).ok_or(Error::<T>::InvalidEraToReward)?;
+
+ // Create the offence and report it through on_offence system
+ let _ = Self::on_offence(
+ core::iter::once(offence_details),
+ &[slash_fraction],
+ session_index,
+ );
+
+ Ok(())
+ }
}
}
diff --git a/substrate/frame/staking/src/tests.rs b/substrate/frame/staking/src/tests.rs
index a698d6d9b1e21b6f66179c966acdbd005e6535e7..554c705bfbb8100afa682f1539957bfcd6a5015b 100644
--- a/substrate/frame/staking/src/tests.rs
+++ b/substrate/frame/staking/src/tests.rs
@@ -4727,7 +4727,7 @@ fn offences_weight_calculated_correctly() {
let zero_offence_weight =
<Test as frame_system::Config>::DbWeight::get().reads_writes(4, 1);
assert_eq!(
- Staking::on_offence(&[], &[Perbill::from_percent(50)], 0),
+ <Staking as OnOffenceHandler<_, _, _>>::on_offence(&[], &[Perbill::from_percent(50)], 0),
zero_offence_weight
);
@@ -4748,7 +4748,7 @@ fn offences_weight_calculated_correctly() {
})
.collect();
assert_eq!(
- Staking::on_offence(
+ <Staking as OnOffenceHandler<_, _, _>>::on_offence(
&offenders,
&[Perbill::from_percent(50)],
0,
@@ -4774,7 +4774,7 @@ fn offences_weight_calculated_correctly() {
;
assert_eq!(
- Staking::on_offence(
+ <Staking as OnOffenceHandler<_, _, _>>::on_offence(
&one_offender,
&[Perbill::from_percent(50)],
0,
@@ -9556,4 +9556,184 @@ mod paged_slashing {
);
});
}
+
+ // Tests for manual_slash extrinsic
+ // Covers the following scenarios:
+ // 1. Basic slashing functionality - verifies root origin slashing works correctly
+ // 2. Slashing with a lower percentage - should have no effect
+ // 3. Slashing with a higher percentage - should increase the slash amount
+ // 4. Slashing in non-existent eras - should fail with an error
+ // 5. Slashing in previous eras - should work within history depth
+ #[test]
+ fn manual_slashing_works() {
+ ExtBuilder::default().validator_count(2).build_and_execute(|| {
+ // setup: Start with era 0
+ start_active_era(0);
+
+ let validator_stash = 11;
+ let initial_balance = Staking::slashable_balance_of(&validator_stash);
+ assert!(initial_balance > 0, "Validator must have stake to be slashed");
+
+ // scenario 1: basic slashing works
+ // this verifies that the manual_slash extrinsic properly slashes a validator when
+ // called with root origin
+ let current_era = CurrentEra::<Test>::get().unwrap();
+ let slash_fraction_1 = Perbill::from_percent(25);
+
+ // only root can call this function
+ assert_noop!(
+ Staking::manual_slash(
+ RuntimeOrigin::signed(10),
+ validator_stash,
+ current_era,
+ slash_fraction_1
+ ),
+ BadOrigin
+ );
+
+ // root can slash
+ assert_ok!(Staking::manual_slash(
+ RuntimeOrigin::root(),
+ validator_stash,
+ current_era,
+ slash_fraction_1
+ ));
+
+ // process offence
+ advance_blocks(1);
+
+ // check if balance was slashed correctly (25%)
+ let balance_after_first_slash = Staking::slashable_balance_of(&validator_stash);
+ let expected_balance_1 = initial_balance - (initial_balance / 4); // 25% slash
+
+ assert!(
+ balance_after_first_slash <= expected_balance_1 &&
+ balance_after_first_slash >= expected_balance_1 - 5,
+ "First slash was not applied correctly. Expected around {}, got {}",
+ expected_balance_1,
+ balance_after_first_slash
+ );
+
+ // clear events from first slash
+ System::reset_events();
+
+ // scenario 2: slashing with a smaller fraction has no effect
+ // when a validator has already been slashed by a higher percentage,
+ // attempting to slash with a lower percentage should have no effect
+ let slash_fraction_2 = Perbill::from_percent(10); // Smaller than 25%
+ assert_ok!(Staking::manual_slash(
+ RuntimeOrigin::root(),
+ validator_stash,
+ current_era,
+ slash_fraction_2
+ ));
+
+ // balance should not change because we already slashed with a higher percentage
+ let balance_after_second_slash = Staking::slashable_balance_of(&validator_stash);
+ assert_eq!(
+ balance_after_first_slash, balance_after_second_slash,
+ "Balance changed after slashing with smaller fraction"
+ );
+
+ // with the new implementation, we should see an OffenceReported event
+ // but no Slashed event yet as the slash will be queued
+ let has_offence_reported = System::events().iter().any(|record| {
+ matches!(
+ record.event,
+ RuntimeEvent::Staking(Event::<Test>::OffenceReported {
+ validator,
+ fraction,
+ ..
+ }) if validator == validator_stash && fraction == slash_fraction_2
+ )
+ });
+ assert!(has_offence_reported, "No OffenceReported event was emitted");
+
+ // verify no Slashed event was emitted yet (since it's queued for later processing)
+ let no_slashed_events = !System::events().iter().any(|record| {
+ matches!(record.event, RuntimeEvent::Staking(Event::<Test>::Slashed { .. }))
+ });
+ assert!(no_slashed_events, "A Slashed event was incorrectly emitted immediately");
+
+ // clear events again
+ System::reset_events();
+
+ // scenario 3: slashing with a larger fraction works
+ // when a validator is slashed with a higher percentage than previous slashes,
+ // their stake should be further reduced to match the new larger slash percentage
+ let slash_fraction_3 = Perbill::from_percent(50); // Larger than 25%
+ assert_ok!(Staking::manual_slash(
+ RuntimeOrigin::root(),
+ validator_stash,
+ current_era,
+ slash_fraction_3
+ ));
+
+ // process offence
+ advance_blocks(1);
+
+ // check if balance was further slashed (from 75% to 50% of original)
+ let balance_after_third_slash = Staking::slashable_balance_of(&validator_stash);
+ let expected_balance_3 = initial_balance / 2; // 50% of original
+
+ assert!(
+ balance_after_third_slash <= expected_balance_3 &&
+ balance_after_third_slash >= expected_balance_3 - 5,
+ "Third slash was not applied correctly. Expected around {}, got {}",
+ expected_balance_3,
+ balance_after_third_slash
+ );
+
+ // verify a Slashed event was emitted
+ assert!(
+ System::events().iter().any(|record| {
+ matches!(
+ record.event,
+ RuntimeEvent::Staking(Event::<Test>::Slashed { staker, .. })
+ if staker == validator_stash
+ )
+ }),
+ "No Slashed event was emitted after effective slash"
+ );
+
+ // scenario 4: slashing in a non-existent era fails
+ // the manual_slash extrinsic should validate that the era exists within history depth
+ assert_noop!(
+ Staking::manual_slash(
+ RuntimeOrigin::root(),
+ validator_stash,
+ 999,
+ slash_fraction_1
+ ),
+ Error::<Test>::InvalidEraToReward
+ );
+
+ // move to next era
+ start_active_era(1);
+
+ // scenario 5: slashing in previous era still works
+ // as long as the era is within history depth, validators can be slashed for past eras
+ assert_ok!(Staking::manual_slash(
+ RuntimeOrigin::root(),
+ validator_stash,
+ 0,
+ Perbill::from_percent(75)
+ ));
+
+ // process offence
+ advance_blocks(1);
+
+ // check balance was further reduced
+ let balance_after_fifth_slash = Staking::slashable_balance_of(&validator_stash);
+ let expected_balance_5 = initial_balance / 4; // 25% of original (75% slashed)
+
+ assert!(
+ balance_after_fifth_slash <= expected_balance_5 &&
+ balance_after_fifth_slash >= expected_balance_5 - 5,
+ "Fifth slash was not applied correctly. Expected around {}, got {}",
+ expected_balance_5,
+ balance_after_fifth_slash
+ );
+ })
+ }
}
diff --git a/substrate/frame/staking/src/weights.rs b/substrate/frame/staking/src/weights.rs
index 92300d39dbf69978d5a347b99927ebdb001ad58d..1ccb534e4c50fcd4c1bd65c0ad599d0615fdbf00 100644
--- a/substrate/frame/staking/src/weights.rs
+++ b/substrate/frame/staking/src/weights.rs
@@ -107,6 +107,7 @@ pub trait WeightInfo {
fn restore_ledger() -> Weight;
fn migrate_currency() -> Weight;
fn apply_slash() -> Weight;
+ fn manual_slash() -> Weight;
}
/// Weights for `pallet_staking` using the Substrate node and recommended hardware.
@@ -897,6 +898,35 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
.saturating_add(T::DbWeight::get().reads(233_u64))
.saturating_add(T::DbWeight::get().writes(133_u64))
}
+ /// Storage: `Staking::CurrentEra` (r:1 w:0)
+ /// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ErasStartSessionIndex` (r:1 w:0)
+ /// Proof: `Staking::ErasStartSessionIndex` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ActiveEra` (r:1 w:0)
+ /// Proof: `Staking::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::Invulnerables` (r:1 w:0)
+ /// Proof: `Staking::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ErasStakersOverview` (r:1 w:0)
+ /// Proof: `Staking::ErasStakersOverview` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+ /// Storage: `Session::DisabledValidators` (r:1 w:1)
+ /// Proof: `Session::DisabledValidators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+ /// Storage: `Session::Validators` (r:1 w:0)
+ /// Proof: `Session::Validators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+ /// Storage: `Staking::ValidatorSlashInEra` (r:1 w:1)
+ /// Proof: `Staking::ValidatorSlashInEra` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::OffenceQueue` (r:1 w:1)
+ /// Proof: `Staking::OffenceQueue` (`max_values`: None, `max_size`: Some(101), added: 2576, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::OffenceQueueEras` (r:1 w:1)
+ /// Proof: `Staking::OffenceQueueEras` (`max_values`: Some(1), `max_size`: Some(2690), added: 3185, mode: `MaxEncodedLen`)
+ fn manual_slash() -> Weight {
+ // Proof Size summary in bytes:
+ // Measured: `514`
+ // Estimated: `4175`
+ // Minimum execution time: 30_000_000 picoseconds.
+ Weight::from_parts(33_000_000, 4175)
+ .saturating_add(RocksDbWeight::get().reads(10_u64))
+ .saturating_add(RocksDbWeight::get().writes(4_u64))
+ }
}
// For backwards compatibility and tests.
@@ -1686,4 +1716,33 @@ impl WeightInfo for () {
.saturating_add(RocksDbWeight::get().reads(233_u64))
.saturating_add(RocksDbWeight::get().writes(133_u64))
}
+ /// Storage: `Staking::CurrentEra` (r:1 w:0)
+ /// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ErasStartSessionIndex` (r:1 w:0)
+ /// Proof: `Staking::ErasStartSessionIndex` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ActiveEra` (r:1 w:0)
+ /// Proof: `Staking::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::Invulnerables` (r:1 w:0)
+ /// Proof: `Staking::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::ErasStakersOverview` (r:1 w:0)
+ /// Proof: `Staking::ErasStakersOverview` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+ /// Storage: `Session::DisabledValidators` (r:1 w:1)
+ /// Proof: `Session::DisabledValidators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+ /// Storage: `Session::Validators` (r:1 w:0)
+ /// Proof: `Session::Validators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+ /// Storage: `Staking::ValidatorSlashInEra` (r:1 w:1)
+ /// Proof: `Staking::ValidatorSlashInEra` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::OffenceQueue` (r:1 w:1)
+ /// Proof: `Staking::OffenceQueue` (`max_values`: None, `max_size`: Some(101), added: 2576, mode: `MaxEncodedLen`)
+ /// Storage: `Staking::OffenceQueueEras` (r:1 w:1)
+ /// Proof: `Staking::OffenceQueueEras` (`max_values`: Some(1), `max_size`: Some(2690), added: 3185, mode: `MaxEncodedLen`)
+ fn manual_slash() -> Weight {
+ // Proof Size summary in bytes:
+ // Measured: `514`
+ // Estimated: `4175`
+ // Minimum execution time: 30_000_000 picoseconds.
+ Weight::from_parts(33_000_000, 4175)
+ .saturating_add(RocksDbWeight::get().reads(10_u64))
+ .saturating_add(RocksDbWeight::get().writes(4_u64))
+ }
}