Finishing "Additional priority boost for relayers that have explicitly registered at lane"

modules/relayers/src/benchmarking.rs

@@ -23,8 +23,10 @@ use crate::*;
 use bp_messages::LaneId;
 use bp_relayers::RewardsAccountOwner;
 use frame_benchmarking::v2::*;
-use frame_system::RawOrigin;
+use frame_support::traits::Get;
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
 use sp_runtime::traits::One;
+use sp_std::vec::Vec;
 
 /// Reward amount that is (hopefully) is larger than existential deposit across all chains.
 const REWARD_AMOUNT: u32 = u32::MAX;
@@ -40,6 +42,47 @@ pub trait Config: crate::Config {
 	fn deposit_account(account: Self::AccountId, balance: Self::Reward);
 }
 
+/// Return lane id that we use in tests.
+fn lane_id(i: u32) -> LaneId {
+	LaneId::new(i, i)
+}
+
+/// Return block number until which our test registration is considered valid.
+fn valid_till<T: Config>() -> BlockNumberFor<T> {
+	frame_system::Pallet::<T>::block_number()
+		.saturating_add(crate::Pallet::<T>::required_registration_lease())
+		.saturating_add(One::one())
+		.saturating_add(One::one())
+}
+
+/// Add basic relayer registration and optionally lane registrations.
+fn register_relayer<T: Config>(
+	relayer: &T::AccountId,
+	lanes_reg_count: u32,
+	expected_reward: RelayerRewardAtSource,
+) {
+	let stake = crate::Pallet::<T>::base_stake().saturating_add(
+		crate::Pallet::<T>::stake_per_lane().saturating_mul((lanes_reg_count + 1).into()),
+	);
+	T::deposit_account(relayer.clone(), stake);
+	crate::Pallet::<T>::increase_stake(RawOrigin::Signed(relayer.clone()).into(), stake).unwrap();
+	crate::Pallet::<T>::register(RawOrigin::Signed(relayer.clone()).into(), valid_till::<T>())
+		.unwrap();
+
+	for i in 0..lanes_reg_count {
+		crate::Pallet::<T>::register_at_lane(
+			RawOrigin::Signed(relayer.clone()).into(),
+			lane_id(i),
+			expected_reward,
+		)
+		.unwrap();
+	}
+	assert_eq!(
+		crate::Pallet::<T>::registered_relayer(&relayer).map(|reg| reg.lanes().len() as u32),
+		Some(lanes_reg_count),
+	);
+}
+
 #[benchmarks]
 mod benchmarks {
 	use super::*;
@@ -64,16 +107,54 @@ mod benchmarks {
 		// also completed successfully
 	}
 
+	/// Benchmark `increase_stake` call.
+	#[benchmark]
+	fn increase_stake() {
+		let relayer: T::AccountId = whitelisted_caller();
+		let stake = crate::Pallet::<T>::base_stake();
+		T::deposit_account(relayer.clone(), stake);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(relayer.clone()), stake);
+
+		assert_eq!(
+			crate::Pallet::<T>::registered_relayer(&relayer).map(|reg| reg.current_stake()),
+			Some(stake),
+		);
+	}
+
+	/// Benchmark `decrease_stake` call.
+	#[benchmark]
+	fn decrease_stake() {
+		let relayer: T::AccountId = whitelisted_caller();
+		let base_stake = crate::Pallet::<T>::base_stake();
+		let stake = base_stake.saturating_add(100u32.into());
+		T::deposit_account(relayer.clone(), stake);
+		crate::Pallet::<T>::increase_stake(RawOrigin::Signed(relayer.clone()).into(), stake)
+			.unwrap();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(relayer.clone()), 100u32.into());
+
+		assert_eq!(
+			crate::Pallet::<T>::registered_relayer(&relayer).map(|reg| reg.current_stake()),
+			Some(base_stake),
+		);
+	}
+
 	/// Benchmark `register` call.
 	#[benchmark]
 	fn register() {
 		let relayer: T::AccountId = whitelisted_caller();
+		let base_stake = crate::Pallet::<T>::base_stake();
 		let valid_till = frame_system::Pallet::<T>::block_number()
 			.saturating_add(crate::Pallet::<T>::required_registration_lease())
 			.saturating_add(One::one())
 			.saturating_add(One::one());
 
-		T::deposit_account(relayer.clone(), crate::Pallet::<T>::required_stake());
+		T::deposit_account(relayer.clone(), base_stake);
+		crate::Pallet::<T>::increase_stake(RawOrigin::Signed(relayer.clone()).into(), base_stake)
+			.unwrap();
 
 		#[extrinsic_call]
 		_(RawOrigin::Signed(relayer.clone()), valid_till);
@@ -85,36 +166,133 @@ mod benchmarks {
 	#[benchmark]
 	fn deregister() {
 		let relayer: T::AccountId = whitelisted_caller();
-		let valid_till = frame_system::Pallet::<T>::block_number()
-			.saturating_add(crate::Pallet::<T>::required_registration_lease())
-			.saturating_add(One::one())
-			.saturating_add(One::one());
-		T::deposit_account(relayer.clone(), crate::Pallet::<T>::required_stake());
-		crate::Pallet::<T>::register(RawOrigin::Signed(relayer.clone()).into(), valid_till)
-			.unwrap();
-
-		frame_system::Pallet::<T>::set_block_number(valid_till.saturating_add(One::one()));
+		register_relayer::<T>(&relayer, 0, 0);
+		frame_system::Pallet::<T>::set_block_number(valid_till::<T>().saturating_add(One::one()));
 
 		#[extrinsic_call]
 		_(RawOrigin::Signed(relayer.clone()));
 
 		assert!(!crate::Pallet::<T>::is_registration_active(&relayer));
 	}
 
+	/// Benchmark `register_at_lane` call. The worst case for this call is when:
+	///
+	/// - relayer has `T::MaxLanesPerRelayer::get() - 1` lane registrations;
+	///
+	/// - there are no other relayers registered at that lane yet;
+	#[benchmark]
+	fn register_at_lane() {
+		let relayer: T::AccountId = whitelisted_caller();
+		let max_lanes_per_relayer = T::MaxLanesPerRelayer::get();
+		register_relayer::<T>(&relayer, max_lanes_per_relayer - 1, 0);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(relayer.clone()), lane_id(max_lanes_per_relayer), 0);
+
+		assert_eq!(
+			crate::Pallet::<T>::registered_relayer(&relayer).map(|reg| reg.lanes().len() as u32),
+			Some(max_lanes_per_relayer),
+		);
+	}
+
+	/// Benchmark `deregister_at_lane` call. The worst case for this call is when relayer is not in
+	/// the active relayers set.
+	#[benchmark]
+	fn deregister_at_lane() {
+		let relayer: T::AccountId = whitelisted_caller();
+		let max_lanes_per_relayer = T::MaxLanesPerRelayer::get();
+		register_relayer::<T>(&relayer, max_lanes_per_relayer, 0);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(relayer.clone()), lane_id(0));
+
+		assert_eq!(
+			crate::Pallet::<T>::registered_relayer(&relayer).map(|reg| reg.lanes().len() as u32),
+			Some(max_lanes_per_relayer - 1),
+		);
+	}
+
+	// Benchmark `advance_lane_epoch` call. The worst case for this call is when active set is
+	// completely replaced with a next set.
+	#[benchmark]
+	fn advance_lane_epoch() {
+		let current_block_number = frame_system::Pallet::<T>::block_number();
+
+		// prepare active relayers set with max possible relayers count
+		let max_active_relayers_per_lane = T::MaxActiveRelayersPerLane::get();
+		let active_relayers = (0..max_active_relayers_per_lane)
+			.map(|i| account("relayer", i, 0))
+			.collect::<Vec<_>>();
+		let mut active_relayers_set =
+			ActiveLaneRelayersSet::<_, BlockNumberFor<T>, T::MaxActiveRelayersPerLane>::default();
+		let mut next_relayers_set =
+			NextLaneRelayersSet::<_, BlockNumberFor<T>, T::MaxNextRelayersPerLane>::empty(
+				current_block_number,
+			);
+		for active_relayer in &active_relayers {
+			register_relayer::<T>(active_relayer, 1, 1);
+			assert!(next_relayers_set.try_insert(active_relayer.clone(), 0));
+		}
+		active_relayers_set.activate_next_set(current_block_number, next_relayers_set, |_| true);
+		ActiveLaneRelayers::<T>::insert(lane_id(0), active_relayers_set);
+
+		// prepare next relayers set with max possible relayers count
+		let max_next_relayers_per_lane = T::MaxNextRelayersPerLane::get();
+		let next_relayers = (0..max_next_relayers_per_lane)
+			.map(|i| account::<T::AccountId>("relayer", max_active_relayers_per_lane + i, 0))
+			.collect::<Vec<_>>();
+		for next_relayer in &next_relayers {
+			register_relayer::<T>(next_relayer, 1, 0);
+		}
+
+		// set next block to block where next set can be activated
+		frame_system::Pallet::<T>::set_block_number(
+			NextLaneRelayers::<T>::get(lane_id(0)).unwrap().may_enact_at(),
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(whitelisted_caller()), lane_id(0));
+
+		// active relayers are replaced with next relayers
+		assert_eq!(
+			crate::Pallet::<T>::active_lane_relayers(&lane_id(0))
+				.relayers()
+				.iter()
+				.map(|r| r.relayer())
+				.collect::<Vec<_>>(),
+			next_relayers.iter().take(max_active_relayers_per_lane as _).collect::<Vec<_>>(),
+		);
+
+		// all (previous) active relayers have no lane registration
+		active_relayers
+			.into_iter()
+			.all(|r| crate::Pallet::<T>::registered_relayer(&r).unwrap().lanes().len() == 0);
+
+		// all (previous) next relayers have no lane registration
+		next_relayers
+			.into_iter()
+			.all(|r| crate::Pallet::<T>::registered_relayer(&r).unwrap().lanes().len() == 1);
+	}
+
 	/// Benchmark `slash_and_deregister` method of the pallet. We are adding this weight to
 	/// the weight of message delivery call if `RefundBridgedParachainMessages` signed extension
 	/// is deployed at runtime level.
 	#[benchmark]
 	fn slash_and_deregister() {
 		// prepare and register relayer account
 		let relayer: T::AccountId = whitelisted_caller();
-		let valid_till = frame_system::Pallet::<T>::block_number()
-			.saturating_add(crate::Pallet::<T>::required_registration_lease())
-			.saturating_add(One::one())
-			.saturating_add(One::one());
-		T::deposit_account(relayer.clone(), crate::Pallet::<T>::required_stake());
-		crate::Pallet::<T>::register(RawOrigin::Signed(relayer.clone()).into(), valid_till)
+		let max_lanes_per_relayer = T::MaxLanesPerRelayer::get();
+		register_relayer::<T>(&relayer, max_lanes_per_relayer, 1);
+
+		// also register relayer in next lane relayers set (with better bid)
+		for i in 0..max_lanes_per_relayer {
+			crate::Pallet::<T>::register_at_lane(
+				RawOrigin::Signed(relayer.clone()).into(),
+				lane_id(i),
+				0,
+			)
 			.unwrap();
+		}
 
 		// create slash destination account
 		let lane = LaneId::new(1, 2);
@@ -128,6 +306,15 @@ mod benchmarks {
 		}
 
 		assert!(!crate::Pallet::<T>::is_registration_active(&relayer));
+		for i in 0..max_lanes_per_relayer {
+			assert!(crate::Pallet::<T>::active_lane_relayers(lane_id(i))
+				.relayer(&relayer)
+				.is_none(),);
+			assert!(crate::Pallet::<T>::next_lane_relayers(lane_id(i))
+				.unwrap_or_else(|| NextLaneRelayersSet::empty(Zero::zero()))
+				.relayer(&relayer)
+				.is_none(),);
+		}
 	}
 
 	// Benchmark `register_relayer_reward` method of the pallet. We are adding this weight to

modules/relayers/src/extension/mod.rs

@@ -1013,6 +1013,11 @@ mod tests {
 		run_test(|| {
 			initialize_environment(100, 100, 100);
 
+			BridgeRelayers::increase_stake(
+				RuntimeOrigin::signed(relayer_account_at_this_chain()),
+				Stake::get(),
+			)
+			.unwrap();
 			BridgeRelayers::register(RuntimeOrigin::signed(relayer_account_at_this_chain()), 1000)
 				.unwrap();
 
@@ -1043,6 +1048,11 @@ mod tests {
 		run_test(|| {
 			initialize_environment(100, 100, 100);
 
+			BridgeRelayers::increase_stake(
+				RuntimeOrigin::signed(relayer_account_at_this_chain()),
+				Stake::get(),
+			)
+			.unwrap();
 			BridgeRelayers::register(RuntimeOrigin::signed(relayer_account_at_this_chain()), 1000)
 				.unwrap();
 
@@ -1579,6 +1589,11 @@ mod tests {
 			);
 
 			// slashing works for message delivery calls
+			BridgeRelayers::increase_stake(
+				RuntimeOrigin::signed(relayer_account_at_this_chain()),
+				test_stake,
+			)
+			.unwrap();
 			BridgeRelayers::register(RuntimeOrigin::signed(relayer_account_at_this_chain()), 1000)
 				.unwrap();
 			assert_eq!(Balances::reserved_balance(relayer_account_at_this_chain()), test_stake);
@@ -1589,6 +1604,11 @@ mod tests {
 				Balances::free_balance(delivery_rewards_account())
 			);
 
+			BridgeRelayers::increase_stake(
+				RuntimeOrigin::signed(relayer_account_at_this_chain()),
+				test_stake,
+			)
+			.unwrap();
 			BridgeRelayers::register(RuntimeOrigin::signed(relayer_account_at_this_chain()), 1000)
 				.unwrap();
 			assert_eq!(Balances::reserved_balance(relayer_account_at_this_chain()), test_stake);
@@ -1599,6 +1619,11 @@ mod tests {
 				Balances::free_balance(delivery_rewards_account())
 			);
 
+			BridgeRelayers::increase_stake(
+				RuntimeOrigin::signed(relayer_account_at_this_chain()),
+				test_stake,
+			)
+			.unwrap();
 			BridgeRelayers::register(RuntimeOrigin::signed(relayer_account_at_this_chain()), 1000)
 				.unwrap();
 			assert_eq!(Balances::reserved_balance(relayer_account_at_this_chain()), test_stake);
@@ -1888,6 +1913,11 @@ mod tests {
 			initialize_environment(100, 100, best_delivered_message);
 
 			// register relayer so it gets priority boost
+			BridgeRelayers::increase_stake(
+				RuntimeOrigin::signed(relayer_account_at_this_chain()),
+				Stake::get(),
+			)
+			.unwrap();
 			BridgeRelayers::register(RuntimeOrigin::signed(relayer_account_at_this_chain()), 1000)
 				.unwrap();