Relayers pallet: extend payment source id (#1907)

* Add Chain::ID const

* Relayers pallet: extend payment source id

* Addressed code review comments

* Fix benchmarks

* Fix dashboards

* Renamings

* Fix compilation

bridges/modules/relayers/src/benchmarking.rs

@@ -20,6 +20,8 @@
 
 use crate::*;
 
+use bp_messages::LaneId;
+use bp_relayers::RewardsAccountOwner;
 use frame_benchmarking::{benchmarks, whitelisted_caller};
 use frame_system::RawOrigin;
 
@@ -32,19 +34,21 @@ pub struct Pallet<T: Config>(crate::Pallet<T>);
 /// Trait that must be implemented by runtime.
 pub trait Config: crate::Config {
 	/// Prepare environment for paying given reward for serving given lane.
-	fn prepare_environment(lane: LaneId, reward: Self::Reward);
+	fn prepare_environment(account_params: RewardsAccountParams, reward: Self::Reward);
 }
 
 benchmarks! {
 	// Benchmark `claim_rewards` call.
 	claim_rewards {
 		let lane = LaneId([0, 0, 0, 0]);
+		let account_params =
+			RewardsAccountParams::new(lane, *b"test", RewardsAccountOwner::ThisChain);
 		let relayer: T::AccountId = whitelisted_caller();
 		let reward = T::Reward::from(REWARD_AMOUNT);
 
-		T::prepare_environment(lane, reward);
-		RelayerRewards::<T>::insert(&relayer, lane, reward);
-	}: _(RawOrigin::Signed(relayer), lane)
+		T::prepare_environment(account_params, reward);
+		RelayerRewards::<T>::insert(&relayer, account_params, reward);
+	}: _(RawOrigin::Signed(relayer), account_params)
 	verify {
 		// we can't check anything here, because `PaymentProcedure` is responsible for
 		// payment logic, so we assume that if call has succeeded, the procedure has

bridges/modules/relayers/src/lib.rs

@@ -20,8 +20,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![warn(missing_docs)]
 
-use bp_messages::LaneId;
-use bp_relayers::{PaymentProcedure, RelayerRewardsKeyProvider};
+use bp_relayers::{PaymentProcedure, RelayerRewardsKeyProvider, RewardsAccountParams};
 use bp_runtime::StorageDoubleMapKeyProvider;
 use frame_support::sp_runtime::Saturating;
 use sp_arithmetic::traits::{AtLeast32BitUnsigned, Zero};
@@ -72,28 +71,32 @@ pub mod pallet {
 		/// Claim accumulated rewards.
 		#[pallet::call_index(0)]
 		#[pallet::weight(T::WeightInfo::claim_rewards())]
-		pub fn claim_rewards(origin: OriginFor<T>, lane_id: LaneId) -> DispatchResult {
+		pub fn claim_rewards(
+			origin: OriginFor<T>,
+			rewards_account_params: RewardsAccountParams,
+		) -> DispatchResult {
 			let relayer = ensure_signed(origin)?;
 
 			RelayerRewards::<T>::try_mutate_exists(
 				&relayer,
-				lane_id,
+				rewards_account_params,
 				|maybe_reward| -> DispatchResult {
 					let reward = maybe_reward.take().ok_or(Error::<T>::NoRewardForRelayer)?;
-					T::PaymentProcedure::pay_reward(&relayer, lane_id, reward).map_err(|e| {
-						log::trace!(
-							target: LOG_TARGET,
-							"Failed to pay {:?} rewards to {:?}: {:?}",
-							lane_id,
-							relayer,
-							e,
-						);
-						Error::<T>::FailedToPayReward
-					})?;
+					T::PaymentProcedure::pay_reward(&relayer, rewards_account_params, reward)
+						.map_err(|e| {
+							log::trace!(
+								target: LOG_TARGET,
+								"Failed to pay {:?} rewards to {:?}: {:?}",
+								rewards_account_params,
+								relayer,
+								e,
+							);
+							Error::<T>::FailedToPayReward
+						})?;
 
 					Self::deposit_event(Event::<T>::RewardPaid {
 						relayer: relayer.clone(),
-						lane_id,
+						rewards_account_params,
 						reward,
 					});
 					Ok(())
@@ -104,23 +107,31 @@ pub mod pallet {
 
 	impl<T: Config> Pallet<T> {
 		/// Register reward for given relayer.
-		pub fn register_relayer_reward(lane_id: LaneId, relayer: &T::AccountId, reward: T::Reward) {
+		pub fn register_relayer_reward(
+			rewards_account_params: RewardsAccountParams,
+			relayer: &T::AccountId,
+			reward: T::Reward,
+		) {
 			if reward.is_zero() {
 				return
 			}
 
-			RelayerRewards::<T>::mutate(relayer, lane_id, |old_reward: &mut Option<T::Reward>| {
-				let new_reward = old_reward.unwrap_or_else(Zero::zero).saturating_add(reward);
-				*old_reward = Some(new_reward);
+			RelayerRewards::<T>::mutate(
+				relayer,
+				rewards_account_params,
+				|old_reward: &mut Option<T::Reward>| {
+					let new_reward = old_reward.unwrap_or_else(Zero::zero).saturating_add(reward);
+					*old_reward = Some(new_reward);
 
-				log::trace!(
-					target: crate::LOG_TARGET,
-					"Relayer {:?} can now claim reward for serving lane {:?}: {:?}",
-					relayer,
-					lane_id,
-					new_reward,
-				);
-			});
+					log::trace!(
+						target: crate::LOG_TARGET,
+						"Relayer {:?} can now claim reward for serving payer {:?}: {:?}",
+						relayer,
+						rewards_account_params,
+						new_reward,
+					);
+				},
+			);
 		}
 	}
 
@@ -131,8 +142,8 @@ pub mod pallet {
 		RewardPaid {
 			/// Relayer account that has been rewarded.
 			relayer: T::AccountId,
-			/// Relayer has received reward for serving this lane.
-			lane_id: LaneId,
+			/// Relayer has received reward from this account.
+			rewards_account_params: RewardsAccountParams,
 			/// Reward amount.
 			reward: T::Reward,
 		},
@@ -166,6 +177,8 @@ mod tests {
 	use mock::{RuntimeEvent as TestEvent, *};
 
 	use crate::Event::RewardPaid;
+	use bp_messages::LaneId;
+	use bp_relayers::RewardsAccountOwner;
 	use frame_support::{
 		assert_noop, assert_ok,
 		traits::fungible::{Inspect, Mutate},
@@ -182,7 +195,10 @@ mod tests {
 	fn root_cant_claim_anything() {
 		run_test(|| {
 			assert_noop!(
-				Pallet::<TestRuntime>::claim_rewards(RuntimeOrigin::root(), TEST_LANE_ID),
+				Pallet::<TestRuntime>::claim_rewards(
+					RuntimeOrigin::root(),
+					TEST_REWARDS_ACCOUNT_PARAMS
+				),
 				DispatchError::BadOrigin,
 			);
 		});
@@ -194,7 +210,7 @@ mod tests {
 			assert_noop!(
 				Pallet::<TestRuntime>::claim_rewards(
 					RuntimeOrigin::signed(REGULAR_RELAYER),
-					TEST_LANE_ID
+					TEST_REWARDS_ACCOUNT_PARAMS
 				),
 				Error::<TestRuntime>::NoRewardForRelayer,
 			);
@@ -204,11 +220,15 @@ mod tests {
 	#[test]
 	fn relayer_cant_claim_if_payment_procedure_fails() {
 		run_test(|| {
-			RelayerRewards::<TestRuntime>::insert(FAILING_RELAYER, TEST_LANE_ID, 100);
+			RelayerRewards::<TestRuntime>::insert(
+				FAILING_RELAYER,
+				TEST_REWARDS_ACCOUNT_PARAMS,
+				100,
+			);
 			assert_noop!(
 				Pallet::<TestRuntime>::claim_rewards(
 					RuntimeOrigin::signed(FAILING_RELAYER),
-					TEST_LANE_ID
+					TEST_REWARDS_ACCOUNT_PARAMS
 				),
 				Error::<TestRuntime>::FailedToPayReward,
 			);
@@ -220,12 +240,19 @@ mod tests {
 		run_test(|| {
 			get_ready_for_events();
 
-			RelayerRewards::<TestRuntime>::insert(REGULAR_RELAYER, TEST_LANE_ID, 100);
+			RelayerRewards::<TestRuntime>::insert(
+				REGULAR_RELAYER,
+				TEST_REWARDS_ACCOUNT_PARAMS,
+				100,
+			);
 			assert_ok!(Pallet::<TestRuntime>::claim_rewards(
 				RuntimeOrigin::signed(REGULAR_RELAYER),
-				TEST_LANE_ID
+				TEST_REWARDS_ACCOUNT_PARAMS
 			));
-			assert_eq!(RelayerRewards::<TestRuntime>::get(REGULAR_RELAYER, TEST_LANE_ID), None);
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(REGULAR_RELAYER, TEST_REWARDS_ACCOUNT_PARAMS),
+				None
+			);
 
 			//Check if the `RewardPaid` event was emitted.
 			assert_eq!(
@@ -234,7 +261,7 @@ mod tests {
 					phase: Phase::Initialization,
 					event: TestEvent::Relayers(RewardPaid {
 						relayer: REGULAR_RELAYER,
-						lane_id: TEST_LANE_ID,
+						rewards_account_params: TEST_REWARDS_ACCOUNT_PARAMS,
 						reward: 100
 					}),
 					topics: vec![],
@@ -244,30 +271,39 @@ mod tests {
 	}
 
 	#[test]
-	fn pay_lane_reward_from_account_actually_pays_reward() {
+	fn pay_reward_from_account_actually_pays_reward() {
 		type Balances = pallet_balances::Pallet<TestRuntime>;
-		type PayLaneRewardFromAccount = bp_relayers::PayLaneRewardFromAccount<Balances, AccountId>;
+		type PayLaneRewardFromAccount = bp_relayers::PayRewardFromAccount<Balances, AccountId>;
 
 		run_test(|| {
-			let lane0_rewards_account =
-				PayLaneRewardFromAccount::lane_rewards_account(LaneId([0, 0, 0, 0]));
-			let lane1_rewards_account =
-				PayLaneRewardFromAccount::lane_rewards_account(LaneId([0, 0, 0, 1]));
+			let in_lane_0 = RewardsAccountParams::new(
+				LaneId([0, 0, 0, 0]),
+				*b"test",
+				RewardsAccountOwner::ThisChain,
+			);
+			let out_lane_1 = RewardsAccountParams::new(
+				LaneId([0, 0, 0, 1]),
+				*b"test",
+				RewardsAccountOwner::BridgedChain,
+			);
 
-			Balances::mint_into(&lane0_rewards_account, 100).unwrap();
-			Balances::mint_into(&lane1_rewards_account, 100).unwrap();
-			assert_eq!(Balances::balance(&lane0_rewards_account), 100);
-			assert_eq!(Balances::balance(&lane1_rewards_account), 100);
+			let in_lane0_rewards_account = PayLaneRewardFromAccount::rewards_account(in_lane_0);
+			let out_lane1_rewards_account = PayLaneRewardFromAccount::rewards_account(out_lane_1);
+
+			Balances::mint_into(&in_lane0_rewards_account, 100).unwrap();
+			Balances::mint_into(&out_lane1_rewards_account, 100).unwrap();
+			assert_eq!(Balances::balance(&in_lane0_rewards_account), 100);
+			assert_eq!(Balances::balance(&out_lane1_rewards_account), 100);
 			assert_eq!(Balances::balance(&1), 0);
 
-			PayLaneRewardFromAccount::pay_reward(&1, LaneId([0, 0, 0, 0]), 100).unwrap();
-			assert_eq!(Balances::balance(&lane0_rewards_account), 0);
-			assert_eq!(Balances::balance(&lane1_rewards_account), 100);
+			PayLaneRewardFromAccount::pay_reward(&1, in_lane_0, 100).unwrap();
+			assert_eq!(Balances::balance(&in_lane0_rewards_account), 0);
+			assert_eq!(Balances::balance(&out_lane1_rewards_account), 100);
 			assert_eq!(Balances::balance(&1), 100);
 
-			PayLaneRewardFromAccount::pay_reward(&1, LaneId([0, 0, 0, 1]), 100).unwrap();
-			assert_eq!(Balances::balance(&lane0_rewards_account), 0);
-			assert_eq!(Balances::balance(&lane1_rewards_account), 0);
+			PayLaneRewardFromAccount::pay_reward(&1, out_lane_1, 100).unwrap();
+			assert_eq!(Balances::balance(&in_lane0_rewards_account), 0);
+			assert_eq!(Balances::balance(&out_lane1_rewards_account), 0);
 			assert_eq!(Balances::balance(&1), 200);
 		});
 	}

bridges/modules/relayers/src/mock.rs

@@ -19,7 +19,7 @@
 use crate as pallet_bridge_relayers;
 
 use bp_messages::LaneId;
-use bp_relayers::PaymentProcedure;
+use bp_relayers::{PaymentProcedure, RewardsAccountOwner, RewardsAccountParams};
 use frame_support::{parameter_types, weights::RuntimeDbWeight};
 use sp_core::H256;
 use sp_runtime::{
@@ -96,7 +96,8 @@ impl pallet_bridge_relayers::Config for TestRuntime {
 }
 
 /// Message lane that we're using in tests.
-pub const TEST_LANE_ID: LaneId = LaneId([0, 0, 0, 0]);
+pub const TEST_REWARDS_ACCOUNT_PARAMS: RewardsAccountParams =
+	RewardsAccountParams::new(LaneId([0, 0, 0, 0]), *b"test", RewardsAccountOwner::ThisChain);
 
 /// Regular relayer that may receive rewards.
 pub const REGULAR_RELAYER: AccountId = 1;
@@ -112,7 +113,7 @@ impl PaymentProcedure<AccountId, Balance> for TestPaymentProcedure {
 
 	fn pay_reward(
 		relayer: &AccountId,
-		_lane_id: LaneId,
+		_lane_id: RewardsAccountParams,
 		_reward: Balance,
 	) -> Result<(), Self::Error> {
 		match *relayer {

bridges/modules/relayers/src/payment_adapter.rs

@@ -18,28 +18,33 @@
 
 use crate::{Config, Pallet};
 
-use bp_messages::source_chain::{DeliveryConfirmationPayments, RelayersRewards};
+use bp_messages::{
+	source_chain::{DeliveryConfirmationPayments, RelayersRewards},
+	LaneId,
+};
+use bp_relayers::{RewardsAccountOwner, RewardsAccountParams};
 use frame_support::{sp_runtime::SaturatedConversion, traits::Get};
 use sp_arithmetic::traits::{Saturating, UniqueSaturatedFrom, Zero};
 use sp_std::{collections::vec_deque::VecDeque, marker::PhantomData, ops::RangeInclusive};
 
 /// Adapter that allows relayers pallet to be used as a delivery+dispatch payment mechanism
 /// for the messages pallet.
-pub struct DeliveryConfirmationPaymentsAdapter<T, DeliveryReward, ConfirmationReward>(
-	PhantomData<(T, DeliveryReward, ConfirmationReward)>,
+pub struct DeliveryConfirmationPaymentsAdapter<T, MI, DeliveryReward, ConfirmationReward>(
+	PhantomData<(T, MI, DeliveryReward, ConfirmationReward)>,
 );
 
-impl<T, DeliveryReward, ConfirmationReward> DeliveryConfirmationPayments<T::AccountId>
-	for DeliveryConfirmationPaymentsAdapter<T, DeliveryReward, ConfirmationReward>
+impl<T, MI, DeliveryReward, ConfirmationReward> DeliveryConfirmationPayments<T::AccountId>
+	for DeliveryConfirmationPaymentsAdapter<T, MI, DeliveryReward, ConfirmationReward>
 where
-	T: Config,
+	T: Config + pallet_bridge_messages::Config<MI>,
+	MI: 'static,
 	DeliveryReward: Get<T::Reward>,
 	ConfirmationReward: Get<T::Reward>,
 {
 	type Error = &'static str;
 
 	fn pay_reward(
-		lane_id: bp_messages::LaneId,
+		lane_id: LaneId,
 		messages_relayers: VecDeque<bp_messages::UnrewardedRelayer<T::AccountId>>,
 		confirmation_relayer: &T::AccountId,
 		received_range: &RangeInclusive<bp_messages::MessageNonce>,
@@ -50,7 +55,11 @@ where
 		register_relayers_rewards::<T>(
 			confirmation_relayer,
 			relayers_rewards,
-			lane_id,
+			RewardsAccountParams::new(
+				lane_id,
+				T::BridgedChainId::get(),
+				RewardsAccountOwner::BridgedChain,
+			),
 			DeliveryReward::get(),
 			ConfirmationReward::get(),
 		);
@@ -61,7 +70,7 @@ where
 fn register_relayers_rewards<T: Config>(
 	confirmation_relayer: &T::AccountId,
 	relayers_rewards: RelayersRewards<T::AccountId>,
-	lane_id: bp_messages::LaneId,
+	lane_id: RewardsAccountParams,
 	delivery_fee: T::Reward,
 	confirmation_fee: T::Reward,
 ) {
@@ -121,13 +130,19 @@ mod tests {
 			register_relayers_rewards::<TestRuntime>(
 				&RELAYER_2,
 				relayers_rewards(),
-				TEST_LANE_ID,
+				TEST_REWARDS_ACCOUNT_PARAMS,
 				50,
 				10,
 			);
 
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_1, TEST_LANE_ID), Some(80));
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_2, TEST_LANE_ID), Some(170));
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_1, TEST_REWARDS_ACCOUNT_PARAMS),
+				Some(80)
+			);
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_2, TEST_REWARDS_ACCOUNT_PARAMS),
+				Some(170)
+			);
 		});
 	}
 
@@ -137,14 +152,23 @@ mod tests {
 			register_relayers_rewards::<TestRuntime>(
 				&RELAYER_3,
 				relayers_rewards(),
-				TEST_LANE_ID,
+				TEST_REWARDS_ACCOUNT_PARAMS,
 				50,
 				10,
 			);
 
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_1, TEST_LANE_ID), Some(80));
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_2, TEST_LANE_ID), Some(120));
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_3, TEST_LANE_ID), Some(50));
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_1, TEST_REWARDS_ACCOUNT_PARAMS),
+				Some(80)
+			);
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_2, TEST_REWARDS_ACCOUNT_PARAMS),
+				Some(120)
+			);
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_3, TEST_REWARDS_ACCOUNT_PARAMS),
+				Some(50)
+			);
 		});
 	}
 
@@ -154,14 +178,23 @@ mod tests {
 			register_relayers_rewards::<TestRuntime>(
 				&RELAYER_3,
 				relayers_rewards(),
-				TEST_LANE_ID,
+				TEST_REWARDS_ACCOUNT_PARAMS,
 				50,
 				1000,
 			);
 
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_1, TEST_LANE_ID), None);
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_2, TEST_LANE_ID), None);
-			assert_eq!(RelayerRewards::<TestRuntime>::get(RELAYER_3, TEST_LANE_ID), Some(250));
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_1, TEST_REWARDS_ACCOUNT_PARAMS),
+				None
+			);
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_2, TEST_REWARDS_ACCOUNT_PARAMS),
+				None
+			);
+			assert_eq!(
+				RelayerRewards::<TestRuntime>::get(RELAYER_3, TEST_REWARDS_ACCOUNT_PARAMS),
+				Some(250)
+			);
 		});
 	}
 }

bridges/modules/relayers/src/weights.rs

@@ -17,9 +17,9 @@
 //! Autogenerated weights for pallet_bridge_relayers
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-02-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-02-27, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `covid`, CPU: `11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz`
+//! HOSTNAME: `serban-ROG-Zephyrus`, CPU: `12th Gen Intel(R) Core(TM) i7-12700H`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
 
 // Executed Command:
@@ -60,7 +60,7 @@ pub struct BridgeWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for BridgeWeight<T> {
 	/// Storage: BridgeRelayers RelayerRewards (r:1 w:1)
 	///
-	/// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(60), added: 2535,
+	/// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540,
 	/// mode: MaxEncodedLen)
 	///
 	/// Storage: System Account (r:1 w:1)
@@ -69,10 +69,10 @@ impl<T: frame_system::Config> WeightInfo for BridgeWeight<T> {
 	/// MaxEncodedLen)
 	fn claim_rewards() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `534`
-		//  Estimated: `5106`
-		// Minimum execution time: 48_239 nanoseconds.
-		Weight::from_parts(50_579_000, 5106)
+		//  Measured:  `275`
+		//  Estimated: `5111`
+		// Minimum execution time: 43_031 nanoseconds.
+		Weight::from_parts(44_527_000, 5111)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -82,7 +82,7 @@ impl<T: frame_system::Config> WeightInfo for BridgeWeight<T> {
 impl WeightInfo for () {
 	/// Storage: BridgeRelayers RelayerRewards (r:1 w:1)
 	///
-	/// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(60), added: 2535,
+	/// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540,
 	/// mode: MaxEncodedLen)
 	///
 	/// Storage: System Account (r:1 w:1)
@@ -91,10 +91,10 @@ impl WeightInfo for () {
 	/// MaxEncodedLen)
 	fn claim_rewards() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `534`
-		//  Estimated: `5106`
-		// Minimum execution time: 48_239 nanoseconds.
-		Weight::from_parts(50_579_000, 5106)
+		//  Measured:  `275`
+		//  Estimated: `5111`
+		// Minimum execution time: 43_031 nanoseconds.
+		Weight::from_parts(44_527_000, 5111)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}