Disputes runtime (#2947)

* disputes module skeleton and storage

* implement dispute module initialization logic

* implement disputes session change logic

* provide dispute skeletons

* deduplication & ancient check

* fix a couple of warnings

* begin provide_dispute_data impl

* flesh out statement set import somewhat

* move ApprovalVote to shared primitives

* add a signing-payload API to explicit dispute statements

* implement statement signature checking

* some bitflags glue for observing changes in disputes

* implement dispute vote import logic

* flesh out everything except slashing

* guide: tweaks

* declare and use punishment trait

* punish validators for inconclusive disputes

* guide: tiny fix

* guide: update docs

* add disputes getter fn

* guide: small change to spam slots handling

* improve spam slots handling and fix some bugs

* finish API of disputes runtime

* define and deposit `RevertTo` log

* begin integrating disputes into para_inherent

* use precomputed slash_for/against

* return candidate hash from process_bitfields

* implement inclusion::collect_disputed

* finish integration into rest of runtime

* add Disputes to initializer

* address suggestions

* use pallet macro

* fix typo

* Update runtime/parachains/src/disputes.rs

* add test: fix pruning

* document specific behavior

* deposit events on dispute changes

* add an allow(unused) on fn disputes

* add a dummy PunishValidators implementation

* add disputes module to Rococo

* add disputes module to westend runtime

* add disputes module to test runtime

* add disputes module to kusama runtime

* guide: prepare for runtime API for checking frozenness

* remove revert digests in favor of state variable

* merge reversions

* Update runtime/parachains/src/disputes.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update runtime/parachains/src/disputes.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update runtime/parachains/src/disputes.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* add byzantine_threshold and supermajority_threshold utilities to primitives

* use primitive helpers

* deposit revert event when freezing chain

* deposit revert log when freezing chain

* test revert event and log are generated when freezing

* add trait to decouple disputes handling from paras inherent handling

* runtime: fix compilation and setup dispute handler

* disputes: add hook for filtering out dispute statements

* disputes: add initializer hooks to DisputesHandler

* runtime: remove disputes pallet from all runtimes

* tag TODOs

* don't import any dispute statements just yet...

* address grumbles

* fix spellcheck, hopefully

* maybe now?

* last spellcheck round

* fix runtime tests

* fix test-runtime

Co-authored-by: thiolliere <gui.thiolliere@gmail.com>
Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>
Co-authored-by: André Silva <andrerfosilva@gmail.com>

polkadot/runtime/parachains/src/mock.rs

@@ -21,7 +21,9 @@ use sp_core::H256;
 use sp_runtime::traits::{
 	BlakeTwo256, IdentityLookup,
 };
-use primitives::v1::{AuthorityDiscoveryId, Balance, BlockNumber, Header, ValidatorIndex};
+use primitives::v1::{
+	AuthorityDiscoveryId, Balance, BlockNumber, Header, ValidatorIndex, SessionIndex,
+};
 use frame_support::parameter_types;
 use frame_support::traits::GenesisBuild;
 use frame_support_test::TestRandomness;
@@ -29,7 +31,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use crate::{
 	inclusion, scheduler, dmp, ump, hrmp, session_info, paras, configuration,
-	initializer, shared,
+	initializer, shared, disputes,
 };
 
 type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
@@ -53,6 +55,7 @@ frame_support::construct_runtime!(
 		Ump: ump::{Pallet, Call, Storage, Event},
 		Hrmp: hrmp::{Pallet, Call, Storage, Event},
 		SessionInfo: session_info::{Pallet, Call, Storage},
+		Disputes: disputes::{Pallet, Storage, Event<T>},
 	}
 );
 
@@ -62,6 +65,8 @@ parameter_types! {
 		frame_system::limits::BlockWeights::simple_max(4 * 1024 * 1024);
 }
 
+pub type AccountId = u64;
+
 impl frame_system::Config for Test {
 	type BaseCallFilter = frame_support::traits::AllowAll;
 	type BlockWeights = BlockWeights;
@@ -136,10 +141,59 @@ impl crate::hrmp::Config for Test {
 	type Currency = pallet_balances::Pallet<Test>;
 }
 
+impl crate::disputes::Config for Test {
+	type Event = Event;
+	type RewardValidators = Self;
+	type PunishValidators = Self;
+}
+
+thread_local! {
+	pub static REWARD_VALIDATORS: RefCell<Vec<(SessionIndex, Vec<ValidatorIndex>)>> = RefCell::new(Vec::new());
+	pub static PUNISH_VALIDATORS_FOR: RefCell<Vec<(SessionIndex, Vec<ValidatorIndex>)>> = RefCell::new(Vec::new());
+	pub static PUNISH_VALIDATORS_AGAINST: RefCell<Vec<(SessionIndex, Vec<ValidatorIndex>)>> = RefCell::new(Vec::new());
+	pub static PUNISH_VALIDATORS_INCONCLUSIVE: RefCell<Vec<(SessionIndex, Vec<ValidatorIndex>)>> = RefCell::new(Vec::new());
+}
+
+impl crate::disputes::RewardValidators for Test {
+	fn reward_dispute_statement(
+		session: SessionIndex,
+		validators: impl IntoIterator<Item=ValidatorIndex>
+	) {
+		REWARD_VALIDATORS.with(|r| r.borrow_mut().push((session, validators.into_iter().collect())))
+	}
+}
+
+impl crate::disputes::PunishValidators for Test {
+	fn punish_for_invalid(
+		session: SessionIndex,
+		validators: impl IntoIterator<Item=ValidatorIndex>,
+	) {
+		PUNISH_VALIDATORS_FOR
+			.with(|r| r.borrow_mut().push((session, validators.into_iter().collect())))
+	}
+
+	fn punish_against_valid(
+		session: SessionIndex,
+		validators: impl IntoIterator<Item=ValidatorIndex>,
+	) {
+		PUNISH_VALIDATORS_AGAINST
+			.with(|r| r.borrow_mut().push((session, validators.into_iter().collect())))
+	}
+
+	fn punish_inconclusive(
+		session: SessionIndex,
+		validators: impl IntoIterator<Item=ValidatorIndex>,
+	) {
+		PUNISH_VALIDATORS_INCONCLUSIVE
+			.with(|r| r.borrow_mut().push((session, validators.into_iter().collect())))
+	}
+}
+
 impl crate::scheduler::Config for Test { }
 
 impl crate::inclusion::Config for Test {
 	type Event = Event;
+	type DisputesHandler = Disputes;
 	type RewardValidators = TestRewardValidators;
 }