babe: report equivocations (#6362)

* slots: create primitives crate for consensus slots

* offences: add method to check if an offence is unknown

* babe: initial equivocation reporting implementation

* babe: organize imports

* babe: working equivocation reporting

* babe: add slot number to equivocation proof

* session: move duplicate traits to session primitives

* babe: move equivocation stuff to its own file

* offences: fix test

* session: don't have primitives depend on frame_support

* babe: use opaque type for key owner proof

* babe: cleanup client equivocation reporting

* babe: cleanup equivocation code in pallet

* babe: allow sending signed equivocation reports

* node: fix compilation

* fix test compilation

* babe: return bool on check_equivocation_proof

* babe: add test for equivocation reporting

* babe: add more tests

* babe: add test for validate unsigned

* babe: take slot number in generate_key_ownership_proof API

* babe: add benchmark for equivocation proof checking

* session: add benchmark for membership proof checking

* offences: fix babe benchmark

* babe: add weights based on benchmark results

* babe: adjust weights after benchmarking on reference hardware

* babe: reorder checks in check_and_report_equivocation

substrate/frame/session/benchmarking/src/lib.rs

@@ -25,20 +25,30 @@ mod mock;
 use sp_std::prelude::*;
 use sp_std::vec;
 
-use frame_system::RawOrigin;
 use frame_benchmarking::benchmarks;
-
-use pallet_session::*;
-use pallet_session::Module as Session;
-
-use pallet_staking::{
-	MAX_NOMINATIONS,
-	benchmarking::create_validator_with_nominators,
+use frame_support::{
+	codec::Decode,
+	storage::StorageValue,
+	traits::{KeyOwnerProofSystem, OnInitialize},
 };
+use frame_system::RawOrigin;
+use pallet_session::{historical::Module as Historical, Module as Session, *};
+use pallet_staking::{
+	benchmarking::create_validator_with_nominators, testing_utils::create_validators,
+	MAX_NOMINATIONS,
+};
+use sp_runtime::traits::{One, StaticLookup};
+
+const MAX_VALIDATORS: u32 = 1000;
 
 pub struct Module<T: Trait>(pallet_session::Module<T>);
+pub trait Trait: pallet_session::Trait + pallet_session::historical::Trait + pallet_staking::Trait {}
 
-pub trait Trait: pallet_session::Trait + pallet_staking::Trait {}
+impl<T: Trait> OnInitialize<T::BlockNumber> for Module<T> {
+	fn on_initialize(n: T::BlockNumber) -> frame_support::weights::Weight {
+		pallet_session::Module::<T>::on_initialize(n)
+	}
+}
 
 benchmarks! {
 	_ {	}
@@ -59,6 +69,88 @@ benchmarks! {
 		let proof: Vec<u8> = vec![0,1,2,3];
 		Session::<T>::set_keys(RawOrigin::Signed(v_controller.clone()).into(), keys, proof)?;
 	}: _(RawOrigin::Signed(v_controller))
+
+	check_membership_proof_current_session {
+		let n in 2 .. MAX_VALIDATORS as u32;
+
+		let (key, key_owner_proof1) = check_membership_proof_setup::<T>(n);
+		let key_owner_proof2 = key_owner_proof1.clone();
+	}: {
+		Historical::<T>::check_proof(key, key_owner_proof1);
+	}
+	verify {
+		assert!(Historical::<T>::check_proof(key, key_owner_proof2).is_some());
+	}
+
+	check_membership_proof_historical_session {
+		let n in 2 .. MAX_VALIDATORS as u32;
+
+		let (key, key_owner_proof1) = check_membership_proof_setup::<T>(n);
+
+		// skip to the next session so that the session is historical
+		// and the membership merkle proof must be checked.
+		Session::<T>::rotate_session();
+
+		let key_owner_proof2 = key_owner_proof1.clone();
+	}: {
+		Historical::<T>::check_proof(key, key_owner_proof1);
+	}
+	verify {
+		assert!(Historical::<T>::check_proof(key, key_owner_proof2).is_some());
+	}
+}
+
+/// Sets up the benchmark for checking a membership proof. It creates the given
+/// number of validators, sets random session keys and then creates a membership
+/// proof for the first authority and returns its key and the proof.
+fn check_membership_proof_setup<T: Trait>(
+	n: u32,
+) -> (
+	(sp_runtime::KeyTypeId, &'static [u8; 32]),
+	sp_session::MembershipProof,
+) {
+	pallet_staking::ValidatorCount::put(n);
+
+	// create validators and set random session keys
+	for (n, who) in create_validators::<T>(n, 1000)
+		.unwrap()
+		.into_iter()
+		.enumerate()
+	{
+		use rand::RngCore;
+		use rand::SeedableRng;
+
+		let validator = T::Lookup::lookup(who).unwrap();
+		let controller = pallet_staking::Module::<T>::bonded(validator).unwrap();
+
+		let keys = {
+			let mut keys = [0u8; 128];
+
+			// we keep the keys for the first validator as 0x00000...
+			if n > 0 {
+				let mut rng = rand::rngs::StdRng::seed_from_u64(n as u64);
+				rng.fill_bytes(&mut keys);
+			}
+
+			keys
+		};
+
+		let keys: T::Keys = Decode::decode(&mut &keys[..]).unwrap();
+		let proof: Vec<u8> = vec![];
+
+		Session::<T>::set_keys(RawOrigin::Signed(controller).into(), keys, proof).unwrap();
+	}
+
+	Module::<T>::on_initialize(T::BlockNumber::one());
+
+	// skip sessions until the new validator set is enacted
+	while Session::<T>::validators().len() < n as usize {
+		Session::<T>::rotate_session();
+	}
+
+	let key = (sp_runtime::KeyTypeId(*b"babe"), &[0u8; 32]);
+
+	(key, Historical::<T>::prove(key).unwrap())
 }
 
 #[cfg(test)]