Enable Offchain Equalise (#5683)

* Master.into() * Remove debug stuff * Better license * Migrate away from SimpleDispatchInfo * Fix test * Revert "Migrate away from SimpleDispatchInfo" This reverts commit dbdd27fa19948f16bd17defdc01d3dd32986df11. * Move to offchain randomness * Fix tests * Fix tests more
2026-06-12 14:41:11 +00:00 · 2020-04-27 18:51:46 +02:00
parent 33d00692d8
commit ee54eff488
20 changed files with 635 additions and 373 deletions
@@ -0,0 +1,188 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Mock file for staking fuzzing.
+
+use sp_runtime::traits::{Convert, SaturatedConversion};
+use frame_support::{impl_outer_origin, impl_outer_dispatch, parameter_types};
+
+type AccountId = u64;
+type AccountIndex = u32;
+type BlockNumber = u64;
+type Balance = u64;
+
+pub type System = frame_system::Module<Test>;
+pub type Balances = pallet_balances::Module<Test>;
+pub type Staking = pallet_staking::Module<Test>;
+pub type Indices = pallet_indices::Module<Test>;
+pub type Session = pallet_session::Module<Test>;
+
+impl_outer_origin! {
+	pub enum Origin for Test  where system = frame_system {}
+}
+
+impl_outer_dispatch! {
+	pub enum Call for Test where origin: Origin {
+		staking::Staking,
+	}
+}
+
+pub struct CurrencyToVoteHandler;
+impl Convert<u64, u64> for CurrencyToVoteHandler {
+	fn convert(x: u64) -> u64 {
+		x
+	}
+}
+impl Convert<u128, u64> for CurrencyToVoteHandler {
+	fn convert(x: u128) -> u64 {
+		x.saturated_into()
+	}
+}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct Test;
+
+impl frame_system::Trait for Test {
+	type Origin = Origin;
+	type DbWeight = ();
+	type BlockExecutionWeight = ();
+	type ExtrinsicBaseWeight = ();
+	type Index = AccountIndex;
+	type BlockNumber = BlockNumber;
+	type Call = Call;
+	type Hash = sp_core::H256;
+	type Hashing = ::sp_runtime::traits::BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = Indices;
+	type Header = sp_runtime::testing::Header;
+	type Event = ();
+	type BlockHashCount = ();
+	type MaximumBlockWeight = ();
+	type AvailableBlockRatio = ();
+	type MaximumBlockLength = ();
+	type Version = ();
+	type ModuleToIndex = ();
+	type AccountData = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = (Balances,);
+}
+parameter_types! {
+	pub const ExistentialDeposit: Balance = 10;
+}
+impl pallet_balances::Trait for Test {
+	type Balance = Balance;
+	type Event = ();
+	type DustRemoval = ();
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+}
+impl pallet_indices::Trait for Test {
+	type AccountIndex = AccountIndex;
+	type Event = ();
+	type Currency = Balances;
+	type Deposit = ();
+}
+parameter_types! {
+	pub const MinimumPeriod: u64 = 5;
+}
+impl pallet_timestamp::Trait for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = MinimumPeriod;
+}
+impl pallet_session::historical::Trait for Test {
+	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Test>;
+}
+
+sp_runtime::impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub foo: sp_runtime::testing::UintAuthorityId,
+	}
+}
+
+pub struct TestSessionHandler;
+impl pallet_session::SessionHandler<AccountId> for TestSessionHandler {
+	const KEY_TYPE_IDS: &'static [sp_runtime::KeyTypeId] = &[];
+
+	fn on_genesis_session<Ks: sp_runtime::traits::OpaqueKeys>(_validators: &[(AccountId, Ks)]) {}
+
+	fn on_new_session<Ks: sp_runtime::traits::OpaqueKeys>(
+		_: bool,
+		_: &[(AccountId, Ks)],
+		_: &[(AccountId, Ks)],
+	) {}
+
+	fn on_disabled(_: usize) {}
+}
+
+impl pallet_session::Trait for Test {
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Test, Staking>;
+	type Keys = SessionKeys;
+	type ShouldEndSession = pallet_session::PeriodicSessions<(), ()>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<(), ()>;
+	type SessionHandler = TestSessionHandler;
+	type Event = ();
+	type ValidatorId = AccountId;
+	type ValidatorIdOf = pallet_staking::StashOf<Test>;
+	type DisabledValidatorsThreshold = ();
+}
+pallet_staking_reward_curve::build! {
+	const I_NPOS: sp_runtime::curve::PiecewiseLinear<'static> = curve!(
+		min_inflation: 0_025_000,
+		max_inflation: 0_100_000,
+		ideal_stake: 0_500_000,
+		falloff: 0_050_000,
+		max_piece_count: 40,
+		test_precision: 0_005_000,
+	);
+}
+parameter_types! {
+	pub const RewardCurve: &'static sp_runtime::curve::PiecewiseLinear<'static> = &I_NPOS;
+	pub const MaxNominatorRewardedPerValidator: u32 = 64;
+	pub const MaxIterations: u32 = 20;
+}
+
+pub type Extrinsic = sp_runtime::testing::TestXt<Call, ()>;
+
+impl<C> frame_system::offchain::SendTransactionTypes<C> for Test where
+	Call: From<C>,
+{
+	type OverarchingCall = Call;
+	type Extrinsic = Extrinsic;
+}
+
+impl pallet_staking::Trait for Test {
+	type Currency = Balances;
+	type UnixTime = pallet_timestamp::Module<Self>;
+	type CurrencyToVote = CurrencyToVoteHandler;
+	type RewardRemainder = ();
+	type Event = ();
+	type Slash = ();
+	type Reward = ();
+	type SessionsPerEra = ();
+	type SlashDeferDuration = ();
+	type SlashCancelOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type BondingDuration = ();
+	type SessionInterface = Self;
+	type RewardCurve = RewardCurve;
+	type NextNewSession = Session;
+	type ElectionLookahead = ();
+	type Call = Call;
+	type MaxIterations = MaxIterations;
+	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
+	type UnsignedPriority = ();
+}
@@ -0,0 +1,152 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Fuzzing for staking pallet.
+
+use honggfuzz::fuzz;
+
+use mock::Test;
+use pallet_staking::testing_utils::{
+	USER, get_seq_phragmen_solution, get_weak_solution, setup_chain_stakers,
+	set_validator_count, signed_account,
+};
+use frame_support::assert_ok;
+use sp_runtime::{traits::Dispatchable, DispatchError};
+
+mod mock;
+
+#[repr(u32)]
+#[allow(dead_code)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Mode {
+	/// Initial submission. This will be rather cheap.
+	InitialSubmission,
+	/// A better submission that will replace the previous ones. This is the most expensive.
+	StrongerSubmission,
+	/// A weak submission that will be rejected. This will be rather cheap.
+	WeakerSubmission,
+}
+
+pub fn new_test_ext() -> Result<sp_io::TestExternalities, std::string::String> {
+	frame_system::GenesisConfig::default().build_storage::<mock::Test>().map(Into::into)
+}
+
+fn main() {
+	let to_range = |x: u32, a: u32, b: u32| {
+		let collapsed = x % b;
+		if collapsed >= a {
+			collapsed
+		} else {
+			collapsed + a
+		}
+	};
+	loop {
+		fuzz!(|data: (u32, u32, u32, u32, u32)| {
+			let (mut num_validators, mut num_nominators, mut edge_per_voter, mut to_elect, mode_u32) = data;
+			let ext = new_test_ext();
+			let mode: Mode = unsafe { std::mem::transmute(mode_u32) };
+			num_validators = to_range(num_validators, 50, 1000);
+			num_nominators = to_range(num_nominators, 50, 2000);
+			edge_per_voter = to_range(edge_per_voter, 1, 16);
+			to_elect = to_range(to_elect, 20, num_validators);
+			let do_reduce = true;
+
+			println!("+++ instance with params {} / {} / {} / {:?}({}) / {}",
+				num_nominators,
+				num_validators,
+				edge_per_voter,
+				mode,
+				mode_u32,
+				to_elect,
+			);
+
+			ext.unwrap_or_default().execute_with(|| {
+				// initial setup
+				set_validator_count::<Test>(to_elect);
+				pallet_staking::testing_utils::init_active_era();
+				setup_chain_stakers::<Test>(
+					num_validators,
+					num_nominators,
+					edge_per_voter,
+				);
+
+				println!("++ Chain setup done.");
+
+				// stuff to submit
+				let (winners, compact, score) = match mode {
+					Mode::InitialSubmission => {
+						/* No need to setup anything */
+						get_seq_phragmen_solution::<Test>(do_reduce)
+					},
+					Mode::StrongerSubmission => {
+						let (winners, compact, score) = get_weak_solution::<Test>(false);
+						println!("Weak on chain score = {:?}", score);
+						assert_ok!(
+							<pallet_staking::Module<Test>>::submit_election_solution(
+								signed_account::<Test>(USER),
+								winners,
+								compact,
+								score,
+								pallet_staking::testing_utils::active_era::<Test>(),
+							)
+						);
+						get_seq_phragmen_solution::<Test>(do_reduce)
+					},
+					Mode::WeakerSubmission => {
+						let (winners, compact, score) = get_seq_phragmen_solution::<Test>(do_reduce);
+						println!("Strong on chain score = {:?}", score);
+						assert_ok!(
+							<pallet_staking::Module<Test>>::submit_election_solution(
+								signed_account::<Test>(USER),
+								winners,
+								compact,
+								score,
+								pallet_staking::testing_utils::active_era::<Test>(),
+							)
+						);
+						get_weak_solution::<Test>(false)
+					}
+				};
+
+				println!("++ Submission ready. Score = {:?}", score);
+
+				// must have chosen correct number of winners.
+				assert_eq!(winners.len() as u32, <pallet_staking::Module<Test>>::validator_count());
+
+				// final call and origin
+				let call = pallet_staking::Call::<Test>::submit_election_solution(
+					winners,
+					compact,
+					score,
+					pallet_staking::testing_utils::active_era::<Test>(),
+				);
+				let caller = signed_account::<Test>(USER);
+
+				// actually submit
+				match mode {
+					Mode::WeakerSubmission => {
+						assert_eq!(
+							call.dispatch(caller.into()).unwrap_err().error,
+							DispatchError::Module { index: 0, error: 15, message: Some("PhragmenWeakSubmission") },
+						);
+					},
+					// NOTE: so exhaustive pattern doesn't work here.. maybe some rust issue? or due to `#[repr(u32)]`?
+					Mode::InitialSubmission | Mode::StrongerSubmission => assert!(call.dispatch(caller.into()).is_ok()),
+				};
+			})
+		});
+	}
+}