Pallet staking events to named enum (#12342)

* Pallet staking events to named enum

* fmt

* update np staking tests

* update remaining events

* update benchmarks

* Update frame/nomination-pools/test-staking/src/lib.rs

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update frame/staking/src/pallet/mod.rs

* Update frame/staking/src/pallet/mod.rs

* Update frame/staking/src/lib.rs

* Update frame/staking/src/pallet/impls.rs

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
Co-authored-by: parity-processbot <>
Co-authored-by: Ankan <10196091+Ank4n@users.noreply.github.com>

substrate/frame/nomination-pools/test-staking/src/lib.rs

@@ -41,7 +41,10 @@ fn pool_lifecycle_e2e() {
 		// have the pool nominate.
 		assert_ok!(Pools::nominate(RuntimeOrigin::signed(10), 1, vec![1, 2, 3]));
 
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Bonded(POOL1_BONDED, 50),]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 50 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![
@@ -56,7 +59,10 @@ fn pool_lifecycle_e2e() {
 
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Bonded(POOL1_BONDED, 10), StakingEvent::Bonded(POOL1_BONDED, 10),]
+			vec![
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+			]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -87,8 +93,8 @@ fn pool_lifecycle_e2e() {
 		assert_eq!(
 			staking_events_since_last_call(),
 			vec![
-				StakingEvent::Unbonded(POOL1_BONDED, 10),
-				StakingEvent::Unbonded(POOL1_BONDED, 10),
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
 			]
 		);
 		assert_eq!(
@@ -131,7 +137,7 @@ fn pool_lifecycle_e2e() {
 
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Withdrawn(POOL1_BONDED, 20),]
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 20 },]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -155,7 +161,10 @@ fn pool_lifecycle_e2e() {
 
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Chilled(POOL1_BONDED), StakingEvent::Unbonded(POOL1_BONDED, 50),]
+			vec![
+				StakingEvent::Chilled { stash: POOL1_BONDED },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 50 },
+			]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -169,7 +178,7 @@ fn pool_lifecycle_e2e() {
 		// pools is fully destroyed now.
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Withdrawn(POOL1_BONDED, 50),]
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 50 },]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -193,7 +202,10 @@ fn pool_slash_e2e() {
 		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
 		assert_eq!(LastPoolId::<Runtime>::get(), 1);
 
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Bonded(POOL1_BONDED, 40)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![
@@ -210,7 +222,10 @@ fn pool_slash_e2e() {
 
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Bonded(POOL1_BONDED, 20), StakingEvent::Bonded(POOL1_BONDED, 20)]
+			vec![
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 20 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 20 }
+			]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -230,8 +245,8 @@ fn pool_slash_e2e() {
 		assert_eq!(
 			staking_events_since_last_call(),
 			vec![
-				StakingEvent::Unbonded(POOL1_BONDED, 10),
-				StakingEvent::Unbonded(POOL1_BONDED, 10)
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 }
 			]
 		);
 		assert_eq!(
@@ -253,9 +268,9 @@ fn pool_slash_e2e() {
 		assert_eq!(
 			staking_events_since_last_call(),
 			vec![
-				StakingEvent::Unbonded(POOL1_BONDED, 10),
-				StakingEvent::Unbonded(POOL1_BONDED, 10),
-				StakingEvent::Unbonded(POOL1_BONDED, 10),
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
 			]
 		);
 
@@ -278,7 +293,10 @@ fn pool_slash_e2e() {
 			2, // slash era 2, affects chunks at era 5 onwards.
 		);
 
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Slashed(POOL1_BONDED, 30)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 30 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![
@@ -302,7 +320,10 @@ fn pool_slash_e2e() {
 				unbonding_eras: bounded_btree_map!(5 => 10, 6 => 5)
 			}
 		);
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Unbonded(POOL1_BONDED, 5)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 5 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![PoolsEvent::Unbonded { member: 21, pool_id: 1, balance: 5, points: 5, era: 6 }]
@@ -327,7 +348,7 @@ fn pool_slash_e2e() {
 		assert_eq!(
 			staking_events_since_last_call(),
 			// a 10 (un-slashed) + 10/2 (slashed) balance from 10 has also been unlocked
-			vec![StakingEvent::Withdrawn(POOL1_BONDED, 15 + 10 + 15)]
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 15 + 10 + 15 }]
 		);
 
 		// now, finally, we can unbond the depositor further than their current limit.
@@ -336,7 +357,7 @@ fn pool_slash_e2e() {
 
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Unbonded(POOL1_BONDED, 10)]
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 }]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -361,7 +382,7 @@ fn pool_slash_e2e() {
 
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Withdrawn(POOL1_BONDED, 10)]
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 10 }]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -388,7 +409,10 @@ fn pool_slash_proportional() {
 		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
 		assert_eq!(LastPoolId::<T>::get(), 1);
 
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Bonded(POOL1_BONDED, 40)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![
@@ -406,9 +430,9 @@ fn pool_slash_proportional() {
 		assert_eq!(
 			staking_events_since_last_call(),
 			vec![
-				StakingEvent::Bonded(POOL1_BONDED, bond),
-				StakingEvent::Bonded(POOL1_BONDED, bond),
-				StakingEvent::Bonded(POOL1_BONDED, bond),
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond },
 			]
 		);
 		assert_eq!(
@@ -428,7 +452,7 @@ fn pool_slash_proportional() {
 
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Unbonded(POOL1_BONDED, bond),]
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond },]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -445,7 +469,7 @@ fn pool_slash_proportional() {
 		assert_ok!(Pools::unbond(RuntimeOrigin::signed(21), 21, bond));
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Unbonded(POOL1_BONDED, bond),]
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond },]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -462,7 +486,7 @@ fn pool_slash_proportional() {
 		assert_ok!(Pools::unbond(RuntimeOrigin::signed(22), 22, bond));
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Unbonded(POOL1_BONDED, bond),]
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond },]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -486,7 +510,10 @@ fn pool_slash_proportional() {
 			100,
 		);
 
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Slashed(POOL1_BONDED, 50)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 50 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![
@@ -517,7 +544,10 @@ fn pool_slash_non_proportional_only_bonded_pool() {
 
 		// create the pool, we know this has id 1.
 		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Bonded(POOL1_BONDED, 40)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![
@@ -531,7 +561,7 @@ fn pool_slash_non_proportional_only_bonded_pool() {
 		assert_ok!(Pools::join(RuntimeOrigin::signed(20), bond, 1));
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Bonded(POOL1_BONDED, bond)]
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond }]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -543,7 +573,7 @@ fn pool_slash_non_proportional_only_bonded_pool() {
 		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, bond));
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Unbonded(POOL1_BONDED, bond)]
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond }]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -567,7 +597,10 @@ fn pool_slash_non_proportional_only_bonded_pool() {
 			100,
 		);
 
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Slashed(POOL1_BONDED, 30)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 30 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![PoolsEvent::PoolSlashed { pool_id: 1, balance: 10 }]
@@ -590,7 +623,10 @@ fn pool_slash_non_proportional_bonded_pool_and_chunks() {
 
 		// create the pool, we know this has id 1.
 		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Bonded(POOL1_BONDED, 40)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![
@@ -604,7 +640,7 @@ fn pool_slash_non_proportional_bonded_pool_and_chunks() {
 		assert_ok!(Pools::join(RuntimeOrigin::signed(20), bond, 1));
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Bonded(POOL1_BONDED, bond)]
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond }]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -616,7 +652,7 @@ fn pool_slash_non_proportional_bonded_pool_and_chunks() {
 		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, bond));
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![StakingEvent::Unbonded(POOL1_BONDED, bond)]
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond }]
 		);
 		assert_eq!(
 			pool_events_since_last_call(),
@@ -640,7 +676,10 @@ fn pool_slash_non_proportional_bonded_pool_and_chunks() {
 			100,
 		);
 
-		assert_eq!(staking_events_since_last_call(), vec![StakingEvent::Slashed(POOL1_BONDED, 50)]);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 50 }]
+		);
 		assert_eq!(
 			pool_events_since_last_call(),
 			vec![

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

@@ -309,13 +309,13 @@ benchmarks! {
 		let reward_amount = slash_amount.saturating_mul(1 + n) / 2;
 		let reward = reward_amount / r;
 		let slash = |id| core::iter::once(
-			<T as StakingConfig>::RuntimeEvent::from(StakingEvent::<T>::Slashed(id, BalanceOf::<T>::from(slash_amount)))
+			<T as StakingConfig>::RuntimeEvent::from(StakingEvent::<T>::Slashed{staker: id, amount: BalanceOf::<T>::from(slash_amount)})
 		);
 		let balance_slash = |id| core::iter::once(
 			<T as BalancesConfig>::RuntimeEvent::from(pallet_balances::Event::<T>::Slashed{who: id, amount: slash_amount.into()})
 		);
 		let chill = |id| core::iter::once(
-			<T as StakingConfig>::RuntimeEvent::from(StakingEvent::<T>::Chilled(id))
+			<T as StakingConfig>::RuntimeEvent::from(StakingEvent::<T>::Chilled{stash: id})
 		);
 		let balance_deposit = |id, amount: u32|
 			<T as BalancesConfig>::RuntimeEvent::from(pallet_balances::Event::<T>::Deposit{who: id, amount: amount.into()});

substrate/frame/staking/src/lib.rs

@@ -953,7 +953,9 @@ where
 		if bonded_eras.first().filter(|(_, start)| offence_session >= *start).is_some() {
 			R::report_offence(reporters, offence)
 		} else {
-			<Pallet<T>>::deposit_event(Event::<T>::OldSlashingReportDiscarded(offence_session));
+			<Pallet<T>>::deposit_event(Event::<T>::OldSlashingReportDiscarded {
+				session_index: offence_session,
+			});
 			Ok(())
 		}
 	}

substrate/frame/staking/src/pallet/impls.rs

@@ -181,14 +181,20 @@ impl<T: Config> Pallet<T> {
 		let validator_exposure_part = Perbill::from_rational(exposure.own, exposure.total);
 		let validator_staking_payout = validator_exposure_part * validator_leftover_payout;
 
-		Self::deposit_event(Event::<T>::PayoutStarted(era, ledger.stash.clone()));
+		Self::deposit_event(Event::<T>::PayoutStarted {
+			era_index: era,
+			validator_stash: ledger.stash.clone(),
+		});
 
 		let mut total_imbalance = PositiveImbalanceOf::<T>::zero();
 		// We can now make total validator payout:
 		if let Some(imbalance) =
 			Self::make_payout(&ledger.stash, validator_staking_payout + validator_commission_payout)
 		{
-			Self::deposit_event(Event::<T>::Rewarded(ledger.stash, imbalance.peek()));
+			Self::deposit_event(Event::<T>::Rewarded {
+				stash: ledger.stash,
+				amount: imbalance.peek(),
+			});
 			total_imbalance.subsume(imbalance);
 		}
 
@@ -208,7 +214,8 @@ impl<T: Config> Pallet<T> {
 			if let Some(imbalance) = Self::make_payout(&nominator.who, nominator_reward) {
 				// Note: this logic does not count payouts for `RewardDestination::None`.
 				nominator_payout_count += 1;
-				let e = Event::<T>::Rewarded(nominator.who.clone(), imbalance.peek());
+				let e =
+					Event::<T>::Rewarded { stash: nominator.who.clone(), amount: imbalance.peek() };
 				Self::deposit_event(e);
 				total_imbalance.subsume(imbalance);
 			}
@@ -232,7 +239,7 @@ impl<T: Config> Pallet<T> {
 		let chilled_as_validator = Self::do_remove_validator(stash);
 		let chilled_as_nominator = Self::do_remove_nominator(stash);
 		if chilled_as_validator || chilled_as_nominator {
-			Self::deposit_event(Event::<T>::Chilled(stash.clone()));
+			Self::deposit_event(Event::<T>::Chilled { stash: stash.clone() });
 		}
 	}
 
@@ -391,13 +398,18 @@ impl<T: Config> Pallet<T> {
 			let era_duration = (now_as_millis_u64 - active_era_start).saturated_into::<u64>();
 			let staked = Self::eras_total_stake(&active_era.index);
 			let issuance = T::Currency::total_issuance();
-			let (validator_payout, rest) = T::EraPayout::era_payout(staked, issuance, era_duration);
+			let (validator_payout, remainder) =
+				T::EraPayout::era_payout(staked, issuance, era_duration);
 
-			Self::deposit_event(Event::<T>::EraPaid(active_era.index, validator_payout, rest));
+			Self::deposit_event(Event::<T>::EraPaid {
+				era_index: active_era.index,
+				validator_payout,
+				remainder,
+			});
 
 			// Set ending era reward.
 			<ErasValidatorReward<T>>::insert(&active_era.index, validator_payout);
-			T::RewardRemainder::on_unbalanced(T::Currency::issue(rest));
+			T::RewardRemainder::on_unbalanced(T::Currency::issue(remainder));
 
 			// Clear offending validators.
 			<OffendingValidators<T>>::kill();

substrate/frame/staking/src/pallet/mod.rs

@@ -653,39 +653,36 @@ pub mod pallet {
 	pub enum Event<T: Config> {
 		/// The era payout has been set; the first balance is the validator-payout; the second is
 		/// the remainder from the maximum amount of reward.
-		/// \[era_index, validator_payout, remainder\]
-		EraPaid(EraIndex, BalanceOf<T>, BalanceOf<T>),
-		/// The nominator has been rewarded by this amount. \[stash, amount\]
-		Rewarded(T::AccountId, BalanceOf<T>),
+		EraPaid { era_index: EraIndex, validator_payout: BalanceOf<T>, remainder: BalanceOf<T> },
+		/// The nominator has been rewarded by this amount.
+		Rewarded { stash: T::AccountId, amount: BalanceOf<T> },
 		/// One staker (and potentially its nominators) has been slashed by the given amount.
-		/// \[staker, amount\]
-		Slashed(T::AccountId, BalanceOf<T>),
+		Slashed { staker: T::AccountId, amount: BalanceOf<T> },
 		/// An old slashing report from a prior era was discarded because it could
-		/// not be processed. \[session_index\]
-		OldSlashingReportDiscarded(SessionIndex),
+		/// not be processed.
+		OldSlashingReportDiscarded { session_index: SessionIndex },
 		/// A new set of stakers was elected.
 		StakersElected,
 		/// An account has bonded this amount. \[stash, amount\]
 		///
 		/// NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,
 		/// it will not be emitted for staking rewards when they are added to stake.
-		Bonded(T::AccountId, BalanceOf<T>),
-		/// An account has unbonded this amount. \[stash, amount\]
-		Unbonded(T::AccountId, BalanceOf<T>),
+		Bonded { stash: T::AccountId, amount: BalanceOf<T> },
+		/// An account has unbonded this amount.
+		Unbonded { stash: T::AccountId, amount: BalanceOf<T> },
 		/// An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`
-		/// from the unlocking queue. \[stash, amount\]
-		Withdrawn(T::AccountId, BalanceOf<T>),
-		/// A nominator has been kicked from a validator. \[nominator, stash\]
-		Kicked(T::AccountId, T::AccountId),
+		/// from the unlocking queue.
+		Withdrawn { stash: T::AccountId, amount: BalanceOf<T> },
+		/// A nominator has been kicked from a validator.
+		Kicked { nominator: T::AccountId, stash: T::AccountId },
 		/// The election failed. No new era is planned.
 		StakingElectionFailed,
 		/// An account has stopped participating as either a validator or nominator.
-		/// \[stash\]
-		Chilled(T::AccountId),
-		/// The stakers' rewards are getting paid. \[era_index, validator_stash\]
-		PayoutStarted(EraIndex, T::AccountId),
+		Chilled { stash: T::AccountId },
+		/// The stakers' rewards are getting paid.
+		PayoutStarted { era_index: EraIndex, validator_stash: T::AccountId },
 		/// A validator has set their preferences.
-		ValidatorPrefsSet(T::AccountId, ValidatorPrefs),
+		ValidatorPrefsSet { stash: T::AccountId, prefs: ValidatorPrefs },
 	}
 
 	#[pallet::error]
@@ -850,7 +847,7 @@ pub mod pallet {
 
 			let stash_balance = T::Currency::free_balance(&stash);
 			let value = value.min(stash_balance);
-			Self::deposit_event(Event::<T>::Bonded(stash.clone(), value));
+			Self::deposit_event(Event::<T>::Bonded { stash: stash.clone(), amount: value });
 			let item = StakingLedger {
 				stash,
 				total: value,
@@ -911,7 +908,7 @@ pub mod pallet {
 						T::VoterList::on_update(&stash, Self::weight_of(&ledger.stash)).defensive();
 				}
 
-				Self::deposit_event(Event::<T>::Bonded(stash, extra));
+				Self::deposit_event(Event::<T>::Bonded { stash, amount: extra });
 			}
 			Ok(())
 		}
@@ -994,7 +991,7 @@ pub mod pallet {
 						.defensive();
 				}
 
-				Self::deposit_event(Event::<T>::Unbonded(ledger.stash, value));
+				Self::deposit_event(Event::<T>::Unbonded { stash: ledger.stash, amount: value });
 			}
 			Ok(())
 		}
@@ -1050,7 +1047,7 @@ pub mod pallet {
 			if ledger.total < old_total {
 				// Already checked that this won't overflow by entry condition.
 				let value = old_total - ledger.total;
-				Self::deposit_event(Event::<T>::Withdrawn(stash, value));
+				Self::deposit_event(Event::<T>::Withdrawn { stash, amount: value });
 			}
 
 			Ok(post_info_weight.into())
@@ -1088,7 +1085,7 @@ pub mod pallet {
 
 			Self::do_remove_nominator(stash);
 			Self::do_add_validator(stash, prefs.clone());
-			Self::deposit_event(Event::<T>::ValidatorPrefsSet(ledger.stash, prefs));
+			Self::deposit_event(Event::<T>::ValidatorPrefsSet { stash: ledger.stash, prefs });
 
 			Ok(())
 		}
@@ -1471,7 +1468,10 @@ pub mod pallet {
 			// Last check: the new active amount of ledger must be more than ED.
 			ensure!(ledger.active >= T::Currency::minimum_balance(), Error::<T>::InsufficientBond);
 
-			Self::deposit_event(Event::<T>::Bonded(ledger.stash.clone(), rebonded_value));
+			Self::deposit_event(Event::<T>::Bonded {
+				stash: ledger.stash.clone(),
+				amount: rebonded_value,
+			});
 
 			// NOTE: ledger must be updated prior to calling `Self::weight_of`.
 			Self::update_ledger(&controller, &ledger);
@@ -1546,10 +1546,10 @@ pub mod pallet {
 					if let Some(ref mut nom) = maybe_nom {
 						if let Some(pos) = nom.targets.iter().position(|v| v == stash) {
 							nom.targets.swap_remove(pos);
-							Self::deposit_event(Event::<T>::Kicked(
-								nom_stash.clone(),
-								stash.clone(),
-							));
+							Self::deposit_event(Event::<T>::Kicked {
+								nominator: nom_stash.clone(),
+								stash: stash.clone(),
+							});
 						}
 					}
 				});

substrate/frame/staking/src/slashing.rs

@@ -626,7 +626,10 @@ pub fn do_slash<T: Config>(
 		<Pallet<T>>::update_ledger(&controller, &ledger);
 
 		// trigger the event
-		<Pallet<T>>::deposit_event(super::Event::<T>::Slashed(stash.clone(), value));
+		<Pallet<T>>::deposit_event(super::Event::<T>::Slashed {
+			staker: stash.clone(),
+			amount: value,
+		});
 	}
 }
 

substrate/frame/staking/src/tests.rs

@@ -303,7 +303,11 @@ fn rewards_should_work() {
 		assert_eq!(mock::RewardRemainderUnbalanced::get(), maximum_payout - total_payout_0,);
 		assert_eq!(
 			*mock::staking_events().last().unwrap(),
-			Event::EraPaid(0, total_payout_0, maximum_payout - total_payout_0)
+			Event::EraPaid {
+				era_index: 0,
+				validator_payout: total_payout_0,
+				remainder: maximum_payout - total_payout_0
+			}
 		);
 		mock::make_all_reward_payment(0);
 
@@ -341,7 +345,11 @@ fn rewards_should_work() {
 		);
 		assert_eq!(
 			*mock::staking_events().last().unwrap(),
-			Event::EraPaid(1, total_payout_1, maximum_payout - total_payout_1)
+			Event::EraPaid {
+				era_index: 1,
+				validator_payout: total_payout_1,
+				remainder: maximum_payout - total_payout_1
+			}
 		);
 		mock::make_all_reward_payment(1);
 
@@ -1645,7 +1653,7 @@ fn rebond_emits_right_value_in_event() {
 			})
 		);
 		// Event emitted should be correct
-		assert_eq!(*staking_events().last().unwrap(), Event::Bonded(11, 100));
+		assert_eq!(*staking_events().last().unwrap(), Event::Bonded { stash: 11, amount: 100 });
 
 		// Re-bond way more than available
 		Staking::rebond(RuntimeOrigin::signed(10), 100_000).unwrap();
@@ -1660,7 +1668,7 @@ fn rebond_emits_right_value_in_event() {
 			})
 		);
 		// Event emitted should be correct, only 800
-		assert_eq!(*staking_events().last().unwrap(), Event::Bonded(11, 800));
+		assert_eq!(*staking_events().last().unwrap(), Event::Bonded { stash: 11, amount: 800 });
 	});
 }
 
@@ -2870,9 +2878,9 @@ fn deferred_slashes_are_deferred() {
 			staking_events_since_last_call(),
 			vec![
 				Event::StakersElected,
-				Event::EraPaid(3, 11075, 33225),
-				Event::Slashed(11, 100),
-				Event::Slashed(101, 12)
+				Event::EraPaid { era_index: 3, validator_payout: 11075, remainder: 33225 },
+				Event::Slashed { staker: 11, amount: 100 },
+				Event::Slashed { staker: 101, amount: 12 }
 			]
 		);
 	})
@@ -2901,9 +2909,9 @@ fn retroactive_deferred_slashes_two_eras_before() {
 			staking_events_since_last_call(),
 			vec![
 				Event::StakersElected,
-				Event::EraPaid(3, 7100, 21300),
-				Event::Slashed(11, 100),
-				Event::Slashed(101, 12)
+				Event::EraPaid { era_index: 3, validator_payout: 7100, remainder: 21300 },
+				Event::Slashed { staker: 11, amount: 100 },
+				Event::Slashed { staker: 101, amount: 12 },
 			]
 		);
 	})
@@ -2934,7 +2942,10 @@ fn retroactive_deferred_slashes_one_before() {
 		mock::start_active_era(4);
 		assert_eq!(
 			staking_events_since_last_call(),
-			vec![Event::StakersElected, Event::EraPaid(3, 11075, 33225)]
+			vec![
+				Event::StakersElected,
+				Event::EraPaid { era_index: 3, validator_payout: 11075, remainder: 33225 }
+			]
 		);
 
 		assert_eq!(Staking::ledger(10).unwrap().total, 1000);
@@ -2944,9 +2955,9 @@ fn retroactive_deferred_slashes_one_before() {
 			staking_events_since_last_call(),
 			vec![
 				Event::StakersElected,
-				Event::EraPaid(4, 11075, 33225),
-				Event::Slashed(11, 100),
-				Event::Slashed(101, 12)
+				Event::EraPaid { era_index: 4, validator_payout: 11075, remainder: 33225 },
+				Event::Slashed { staker: 11, amount: 100 },
+				Event::Slashed { staker: 101, amount: 12 }
 			]
 		);
 
@@ -3090,9 +3101,9 @@ fn remove_deferred() {
 			staking_events_since_last_call(),
 			vec![
 				Event::StakersElected,
-				Event::EraPaid(3, 11075, 33225),
-				Event::Slashed(11, 50),
-				Event::Slashed(101, 7)
+				Event::EraPaid { era_index: 3, validator_payout: 11075, remainder: 33225 },
+				Event::Slashed { staker: 11, amount: 50 },
+				Event::Slashed { staker: 101, amount: 7 }
 			]
 		);
 
@@ -4057,7 +4068,7 @@ fn offences_weight_calculated_correctly() {
 				&one_offender,
 				&[Perbill::from_percent(50)],
 				0,
-				DisableStrategy::WhenSlashed
+				DisableStrategy::WhenSlashed{}
 			),
 			one_offence_unapplied_weight
 		);
@@ -4955,10 +4966,10 @@ fn min_commission_works() {
 		// event emitted should be correct
 		assert_eq!(
 			*staking_events().last().unwrap(),
-			Event::ValidatorPrefsSet(
-				11,
-				ValidatorPrefs { commission: Perbill::from_percent(5), blocked: false }
-			)
+			Event::ValidatorPrefsSet {
+				stash: 11,
+				prefs: ValidatorPrefs { commission: Perbill::from_percent(5), blocked: false }
+			}
 		);
 
 		assert_ok!(Staking::set_staking_configs(