Introduction of Approval Slashes [Disabling Strategy Stage 4] (#6827)

Implementation of Stage 4 of the new [Disabling
Strategy](#4359).

Stage 3 needs to be deployed before this goes live. ([Stage 3
PR](#5724))

Currently only backers are ever slashed as a result of disputes.

This PR creates 3 types of offences with respective slashes:
- ForInvalidBacked (100%) -> hard punishment as backers bear all the
responsbility for validity
- ForInvalidApproved (2%) -> minor punishment to deter lazy validators
- AgainstValid (0%) -> very minor punishment (this causes disablement so
opp cost)

Closes #4746

IMPL details:

This will require a change to parachains primitives which are used both
on the runtime and node side. Rolling it out is time consuming so the
plan is to release it in 2 parts.

First updade runtime only with new offence types but keep old runtime
apis (mapping from new format to old) so the node logic can remain the
same. This will allow us to have the new offences for disputes
concluding on-chain. Past session disputes that require proof
submissions will temporarily not support the new slash types (but they
are rarer). This will make the network more robust in the short term (as
it is much easier to deploy).

As the second part we can update the runtime apis and node side to fully
support the new types.

TODOs:

- [x] new offence types
- [ ] ~~migrations~~ (migration not needed because codec is compatible
in conversion from old->new)
- [ ] ~~migration tests~~
- [x] conversion (new -> old) to preserve old runtime apis
- [x] conversion of disputeProofs (old -> new) to maintain old past
session dispute behaviour
- [ ] new runtime apis (postponed for later)
- [x] disabling for spammy validators zombienet test
- [x] disabling for lazy validators zombienet test
- [ ] unit tests

---------

Co-authored-by: ordian <[email protected]>
Co-authored-by: Stephane Gurgenidze <[email protected]>
Co-authored-by: ordian <[email protected]>

Author: 3 people

polkadot/primitives/src/v8/slashing.rs

@@ -21,7 +21,11 @@ use alloc::{collections::btree_map::BTreeMap, vec::Vec};
 use codec::{Decode, DecodeWithMemTracking, Encode};
 use scale_info::TypeInfo;
 
-/// The kind of the dispute offence.
+/// The kind of the slashing offence (those come from disputes).
+///
+/// Notes:
+/// Will soon be fully eclipsed by the expanded `DisputeOffenceKind` enum.
+/// Only kept for backwards compatibility through old runtime apis.
 #[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, TypeInfo, Debug)]
 pub enum SlashingOffenceKind {
 	/// A severe offence when a validator backed an invalid block.
@@ -54,6 +58,11 @@ impl DisputesTimeSlot {
 
 /// We store most of the information about a lost dispute on chain. This struct
 /// is required to identify and verify it.
+///
+/// Notes:
+/// Will soon be fully eclipsed by the expanded vstaging `DisputeProof` struct
+/// that uses the newer `DisputeOffenceKind` enum instead.
+/// Only kept for backwards compatibility.
 #[derive(PartialEq, Eq, Clone, Encode, Decode, DecodeWithMemTracking, TypeInfo, Debug)]
 pub struct DisputeProof {
 	/// Time slot when the dispute occurred.
@@ -68,6 +77,11 @@ pub struct DisputeProof {
 
 /// Slashes that are waiting to be applied once we have validator key
 /// identification.
+///
+/// Notes:
+/// Will soon be fully eclipsed by the expanded vstaging `PendingSlashes` struct
+/// that uses the newer `DisputeOffenceKind` enum instead.
+/// Only kept for backwards compatibility.
 #[derive(Encode, Decode, TypeInfo, Debug, Clone)]
 pub struct PendingSlashes {
 	/// Indices and keys of the validators who lost a dispute and are pending

polkadot/primitives/src/vstaging/mod.rs

@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Staging Primitives.
-use crate::{ValidatorIndex, ValidityAttestation};
+use crate::{slashing::DisputesTimeSlot, ValidatorId, ValidatorIndex, ValidityAttestation};
 
 // Put any primitives used by staging APIs functions here
 use super::{
@@ -1036,7 +1036,7 @@ pub fn transpose_claim_queue(
 }
 
 #[cfg(test)]
-mod tests {
+mod candidate_receipt_tests {
 	use super::*;
 	use crate::{
 		v8::{
@@ -1503,3 +1503,110 @@ mod tests {
 		assert_eq!(old_ccr_hash, new_ccr.hash());
 	}
 }
+
+// Approval Slashes primitives
+/// Supercedes the old 'SlashingOffenceKind' enum.
+#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, TypeInfo, Debug)]
+pub enum DisputeOffenceKind {
+	/// A severe offence when a validator backed an invalid block
+	/// (backing only)
+	#[codec(index = 0)]
+	ForInvalidBacked,
+	/// A minor offence when a validator disputed a valid block.
+	/// (approval checking and dispute vote only)
+	#[codec(index = 1)]
+	AgainstValid,
+	/// A medium offence when a validator approved an invalid block
+	/// (approval checking and dispute vote only)
+	#[codec(index = 2)]
+	ForInvalidApproved,
+}
+
+/// impl for a conversion from SlashingOffenceKind to DisputeOffenceKind
+/// This creates DisputeOffenceKind that never contains ForInvalidApproved since it was not
+/// supported in the past
+impl From<super::v8::slashing::SlashingOffenceKind> for DisputeOffenceKind {
+	fn from(value: super::v8::slashing::SlashingOffenceKind) -> Self {
+		match value {
+			super::v8::slashing::SlashingOffenceKind::ForInvalid => Self::ForInvalidBacked,
+			super::v8::slashing::SlashingOffenceKind::AgainstValid => Self::AgainstValid,
+		}
+	}
+}
+
+/// impl for a tryFrom conversion from DisputeOffenceKind to SlashingOffenceKind
+impl TryFrom<DisputeOffenceKind> for super::v8::slashing::SlashingOffenceKind {
+	type Error = ();
+
+	fn try_from(value: DisputeOffenceKind) -> Result<Self, Self::Error> {
+		match value {
+			DisputeOffenceKind::ForInvalidBacked => Ok(Self::ForInvalid),
+			DisputeOffenceKind::AgainstValid => Ok(Self::AgainstValid),
+			DisputeOffenceKind::ForInvalidApproved => Err(()),
+		}
+	}
+}
+
+/// Slashes that are waiting to be applied once we have validator key
+/// identification.
+#[derive(Encode, Decode, TypeInfo, Debug, Clone)]
+pub struct PendingSlashes {
+	/// Indices and keys of the validators who lost a dispute and are pending
+	/// slashes.
+	pub keys: BTreeMap<ValidatorIndex, ValidatorId>,
+	/// The dispute outcome.
+	pub kind: DisputeOffenceKind,
+}
+
+impl From<super::v8::slashing::PendingSlashes> for PendingSlashes {
+	fn from(old: super::v8::slashing::PendingSlashes) -> Self {
+		let keys = old.keys;
+		let kind = old.kind.into();
+		Self { keys, kind }
+	}
+}
+
+impl TryFrom<PendingSlashes> for super::v8::slashing::PendingSlashes {
+	type Error = ();
+
+	fn try_from(value: PendingSlashes) -> Result<Self, Self::Error> {
+		Ok(Self { keys: value.keys, kind: value.kind.try_into()? })
+	}
+}
+
+/// We store most of the information about a lost dispute on chain. This struct
+/// is required to identify and verify it.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, DecodeWithMemTracking, TypeInfo, Debug)]
+pub struct DisputeProof {
+	/// Time slot when the dispute occurred.
+	pub time_slot: DisputesTimeSlot,
+	/// The dispute outcome.
+	pub kind: DisputeOffenceKind,
+	/// The index of the validator who lost a dispute.
+	pub validator_index: ValidatorIndex,
+	/// The parachain session key of the validator.
+	pub validator_id: ValidatorId,
+}
+
+impl From<super::v8::slashing::DisputeProof> for DisputeProof {
+	fn from(old: super::v8::slashing::DisputeProof) -> Self {
+		let time_slot = old.time_slot;
+		let kind = old.kind.into(); // infallible conversion
+		let validator_index = old.validator_index;
+		let validator_id = old.validator_id;
+		Self { time_slot, kind, validator_index, validator_id }
+	}
+}
+
+impl TryFrom<DisputeProof> for super::v8::slashing::DisputeProof {
+	type Error = ();
+
+	fn try_from(value: DisputeProof) -> Result<Self, Self::Error> {
+		Ok(Self {
+			time_slot: value.time_slot,
+			kind: value.kind.try_into()?,
+			validator_index: value.validator_index,
+			validator_id: value.validator_id,
+		})
+	}
+}

polkadot/runtime/parachains/src/disputes.rs

@@ -83,17 +83,18 @@ impl RewardValidators for () {
 
 /// Punishment hooks for disputes.
 pub trait SlashingHandler<BlockNumber> {
-	/// Punish a series of validators who were for an invalid parablock. This is
-	/// expected to be a major punishment.
+	/// Punish a series of validators who were for an invalid parablock.
+	/// This is expected to trigger a large punishment for backers
+	/// and a medium punishment for other approvers.
 	fn punish_for_invalid(
 		session: SessionIndex,
 		candidate_hash: CandidateHash,
 		losers: impl IntoIterator<Item = ValidatorIndex>,
 		backers: impl IntoIterator<Item = ValidatorIndex>,
 	);
 
-	/// Punish a series of validators who were against a valid parablock. This
-	/// is expected to be a minor punishment.
+	/// Punish a series of validators who were against a valid parablock.
+	/// This is expected to be a minor punishment.
 	fn punish_against_valid(
 		session: SessionIndex,
 		candidate_hash: CandidateHash,