Introduce bridge relayers pallet (#1513)

* introduce relayers pallet

* add MessageDeliveryAndDispatchPaymentAdapter

* plug in pallet into test runtimes

* tests prototype

* tests for the relayers pallet

* tests for payment adapter

* mint_reward_payment_procedure_actually_mints_tokens

* benchmarks

* remove irrelevant todo

* remove redundant clone

bridges/modules/relayers/src/benchmarking.rs

@@ -0,0 +1,40 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Benchmarks for the relayers Pallet.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::*;
+
+use frame_benchmarking::{benchmarks, whitelisted_caller};
+use frame_system::RawOrigin;
+
+/// Reward amount that is (hopefully) is larger than existential deposit across all chains.
+const REWARD_AMOUNT: u32 = u32::MAX;
+
+benchmarks! {
+	// Benchmark `claim_rewards` call.
+	claim_rewards {
+		let relayer: T::AccountId = whitelisted_caller();
+		RelayerRewards::<T>::insert(&relayer, T::Reward::from(REWARD_AMOUNT));
+	}: _(RawOrigin::Signed(relayer))
+	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
+		// also completed successfully
+	}
+}

bridges/modules/relayers/src/lib.rs

@@ -0,0 +1,170 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Runtime module that is used to store relayer rewards and (in the future) to
+//! coordinate relations between relayers.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![warn(missing_docs)]
+
+use bp_relayers::PaymentProcedure;
+use sp_arithmetic::traits::AtLeast32BitUnsigned;
+use sp_std::marker::PhantomData;
+use weights::WeightInfo;
+
+pub use pallet::*;
+pub use payment_adapter::MessageDeliveryAndDispatchPaymentAdapter;
+
+mod benchmarking;
+mod mock;
+mod payment_adapter;
+
+pub mod weights;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
+		/// Type of relayer reward.
+		type Reward: AtLeast32BitUnsigned + Copy + Parameter + MaxEncodedLen;
+		/// Pay rewards adapter.
+		type PaymentProcedure: PaymentProcedure<Self::AccountId, Self::Reward>;
+		/// Pallet call weights.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Claim accumulated rewards.
+		#[pallet::weight(T::WeightInfo::claim_rewards())]
+		pub fn claim_rewards(origin: OriginFor<T>) -> DispatchResult {
+			let relayer = ensure_signed(origin)?;
+
+			RelayerRewards::<T>::try_mutate_exists(&relayer, |maybe_reward| -> DispatchResult {
+				let reward = maybe_reward.take().ok_or(Error::<T>::NoRewardForRelayer)?;
+				T::PaymentProcedure::pay_reward(&relayer, reward).map_err(|e| {
+					log::trace!(
+						target: "runtime::bridge-relayers",
+						"Failed to pay rewards to {:?}: {:?}",
+						relayer,
+						e,
+					);
+					Error::<T>::FailedToPayReward
+				})?;
+
+				Self::deposit_event(Event::<T>::RewardPaid { relayer: relayer.clone(), reward });
+				Ok(())
+			})
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Reward has been paid to the relayer.
+		RewardPaid {
+			/// Relayer account that has been rewarded.
+			relayer: T::AccountId,
+			/// Reward amount.
+			reward: T::Reward,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// No reward can be claimed by given relayer.
+		NoRewardForRelayer,
+		/// Reward payment procedure has failed.
+		FailedToPayReward,
+	}
+
+	/// Map of the relayer => accumulated reward.
+	#[pallet::storage]
+	pub type RelayerRewards<T: Config> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, T::Reward, OptionQuery>;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use mock::*;
+
+	use frame_support::{assert_noop, assert_ok, traits::fungible::Inspect};
+	use sp_runtime::DispatchError;
+
+	#[test]
+	fn root_cant_claim_anything() {
+		run_test(|| {
+			assert_noop!(
+				Pallet::<TestRuntime>::claim_rewards(Origin::root()),
+				DispatchError::BadOrigin,
+			);
+		});
+	}
+
+	#[test]
+	fn relayer_cant_claim_if_no_reward_exists() {
+		run_test(|| {
+			assert_noop!(
+				Pallet::<TestRuntime>::claim_rewards(Origin::signed(REGULAR_RELAYER)),
+				Error::<TestRuntime>::NoRewardForRelayer,
+			);
+		});
+	}
+
+	#[test]
+	fn relayer_cant_claim_if_payment_procedure_fails() {
+		run_test(|| {
+			RelayerRewards::<TestRuntime>::insert(FAILING_RELAYER, 100);
+			assert_noop!(
+				Pallet::<TestRuntime>::claim_rewards(Origin::signed(FAILING_RELAYER)),
+				Error::<TestRuntime>::FailedToPayReward,
+			);
+		});
+	}
+
+	#[test]
+	fn relayer_can_claim_reward() {
+		run_test(|| {
+			RelayerRewards::<TestRuntime>::insert(REGULAR_RELAYER, 100);
+			assert_ok!(Pallet::<TestRuntime>::claim_rewards(Origin::signed(REGULAR_RELAYER)));
+			assert_eq!(RelayerRewards::<TestRuntime>::get(REGULAR_RELAYER), None);
+		});
+	}
+
+	#[test]
+	fn mint_reward_payment_procedure_actually_mints_tokens() {
+		type Balances = pallet_balances::Pallet<TestRuntime>;
+
+		run_test(|| {
+			assert_eq!(Balances::balance(&1), 0);
+			assert_eq!(Balances::total_issuance(), 0);
+			bp_relayers::MintReward::<Balances, AccountId>::pay_reward(&1, 100).unwrap();
+			assert_eq!(Balances::balance(&1), 100);
+			assert_eq!(Balances::total_issuance(), 100);
+		});
+	}
+}

bridges/modules/relayers/src/mock.rs

@@ -0,0 +1,156 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg(test)]
+
+use crate as pallet_bridge_relayers;
+
+use bp_messages::{source_chain::ForbidOutboundMessages, target_chain::ForbidInboundMessages};
+use bp_relayers::PaymentProcedure;
+use frame_support::{parameter_types, weights::RuntimeDbWeight};
+use sp_core::H256;
+use sp_runtime::{
+	testing::Header as SubstrateHeader,
+	traits::{BlakeTwo256, IdentityLookup},
+};
+
+pub type AccountId = u64;
+pub type Balance = u64;
+
+type Block = frame_system::mocking::MockBlock<TestRuntime>;
+type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<TestRuntime>;
+
+frame_support::construct_runtime! {
+	pub enum TestRuntime where
+		Block = Block,
+		NodeBlock = Block,
+		UncheckedExtrinsic = UncheckedExtrinsic,
+	{
+		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Event<T>},
+		Messages: pallet_bridge_messages::{Pallet, Event<T>},
+		Relayers: pallet_bridge_relayers::{Pallet, Call, Event<T>},
+	}
+}
+
+parameter_types! {
+	pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight { read: 1, write: 2 };
+}
+
+impl frame_system::Config for TestRuntime {
+	type Origin = Origin;
+	type Index = u64;
+	type Call = Call;
+	type BlockNumber = u64;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Header = SubstrateHeader;
+	type Event = Event;
+	type BlockHashCount = frame_support::traits::ConstU64<250>;
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<Balance>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type BaseCallFilter = frame_support::traits::Everything;
+	type SystemWeightInfo = ();
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = DbWeight;
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_balances::Config for TestRuntime {
+	type MaxLocks = ();
+	type Balance = Balance;
+	type DustRemoval = ();
+	type Event = Event;
+	type ExistentialDeposit = frame_support::traits::ConstU64<1>;
+	type AccountStore = frame_system::Pallet<TestRuntime>;
+	type WeightInfo = ();
+	type MaxReserves = ();
+	type ReserveIdentifier = ();
+}
+
+parameter_types! {
+	pub const TestBridgedChainId: bp_runtime::ChainId = *b"test";
+}
+
+// we're not testing messages pallet here, so values in this config might be crazy
+impl pallet_bridge_messages::Config for TestRuntime {
+	type Event = Event;
+	type WeightInfo = ();
+	type Parameter = ();
+	type MaxMessagesToPruneAtOnce = frame_support::traits::ConstU64<0>;
+	type MaxUnrewardedRelayerEntriesAtInboundLane = frame_support::traits::ConstU64<8>;
+	type MaxUnconfirmedMessagesAtInboundLane = frame_support::traits::ConstU64<8>;
+
+	type MaximalOutboundPayloadSize = frame_support::traits::ConstU32<1024>;
+	type OutboundPayload = ();
+	type OutboundMessageFee = Balance;
+
+	type InboundPayload = ();
+	type InboundMessageFee = Balance;
+	type InboundRelayer = AccountId;
+
+	type TargetHeaderChain = ForbidOutboundMessages;
+	type LaneMessageVerifier = ForbidOutboundMessages;
+	type MessageDeliveryAndDispatchPayment = ();
+	type OnMessageAccepted = ();
+	type OnDeliveryConfirmed = ();
+
+	type SourceHeaderChain = ForbidInboundMessages;
+	type MessageDispatch = ForbidInboundMessages;
+	type BridgedChainId = TestBridgedChainId;
+}
+
+impl pallet_bridge_relayers::Config for TestRuntime {
+	type Event = Event;
+	type Reward = Balance;
+	type PaymentProcedure = TestPaymentProcedure;
+	type WeightInfo = ();
+}
+
+/// Regular relayer that may receive rewards.
+pub const REGULAR_RELAYER: AccountId = 1;
+
+/// Relayer that can't receive rewards.
+pub const FAILING_RELAYER: AccountId = 2;
+
+/// Payment procedure that rejects payments to the `FAILING_RELAYER`.
+pub struct TestPaymentProcedure;
+
+impl PaymentProcedure<AccountId, Balance> for TestPaymentProcedure {
+	type Error = ();
+
+	fn pay_reward(relayer: &AccountId, _reward: Balance) -> Result<(), Self::Error> {
+		match *relayer {
+			FAILING_RELAYER => Err(()),
+			_ => Ok(()),
+		}
+	}
+}
+
+/// Run pallet test.
+pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
+	let t = frame_system::GenesisConfig::default().build_storage::<TestRuntime>().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(test)
+}

bridges/modules/relayers/src/payment_adapter.rs

@@ -0,0 +1,180 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Code that allows relayers pallet to be used as a delivery+dispatch payment mechanism
+//! for the messages pallet.
+
+use crate::{Config, RelayerRewards};
+
+use bp_messages::source_chain::{MessageDeliveryAndDispatchPayment, RelayersRewards};
+use frame_support::traits::Get;
+use sp_arithmetic::traits::{Bounded, Saturating, 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 MessageDeliveryAndDispatchPaymentAdapter<T, MessagesInstance, GetConfirmationFee>(
+	PhantomData<(T, MessagesInstance, GetConfirmationFee)>,
+);
+
+impl<T, MessagesInstance, GetConfirmationFee>
+	MessageDeliveryAndDispatchPayment<T::Origin, T::AccountId, T::Reward>
+	for MessageDeliveryAndDispatchPaymentAdapter<T, MessagesInstance, GetConfirmationFee>
+where
+	T: Config + pallet_bridge_messages::Config<MessagesInstance, OutboundMessageFee = T::Reward>,
+	MessagesInstance: 'static,
+	GetConfirmationFee: Get<T::Reward>,
+{
+	type Error = &'static str;
+
+	fn pay_delivery_and_dispatch_fee(
+		_submitter: &T::Origin,
+		_fee: &T::Reward,
+	) -> Result<(), Self::Error> {
+		// nothing shall happen here, because XCM deals with fee payment (planned to be burnt?
+		// or transferred to the treasury?)
+		Ok(())
+	}
+
+	fn pay_relayers_rewards(
+		lane_id: bp_messages::LaneId,
+		messages_relayers: VecDeque<bp_messages::UnrewardedRelayer<T::AccountId>>,
+		confirmation_relayer: &T::AccountId,
+		received_range: &RangeInclusive<bp_messages::MessageNonce>,
+	) {
+		let relayers_rewards = pallet_bridge_messages::calc_relayers_rewards::<T, MessagesInstance>(
+			lane_id,
+			messages_relayers,
+			received_range,
+		);
+		if !relayers_rewards.is_empty() {
+			schedule_relayers_rewards::<T>(
+				confirmation_relayer,
+				relayers_rewards,
+				GetConfirmationFee::get(),
+			);
+		}
+	}
+}
+
+// Update rewards to given relayers, optionally rewarding confirmation relayer.
+fn schedule_relayers_rewards<T: Config>(
+	confirmation_relayer: &T::AccountId,
+	relayers_rewards: RelayersRewards<T::AccountId, T::Reward>,
+	confirmation_fee: T::Reward,
+) {
+	// reward every relayer except `confirmation_relayer`
+	let mut confirmation_relayer_reward = T::Reward::zero();
+	for (relayer, reward) in relayers_rewards {
+		let mut relayer_reward = reward.reward;
+
+		if relayer != *confirmation_relayer {
+			// If delivery confirmation is submitted by other relayer, let's deduct confirmation fee
+			// from relayer reward.
+			//
+			// If confirmation fee has been increased (or if it was the only component of message
+			// fee), then messages relayer may receive zero reward.
+			let mut confirmation_reward = T::Reward::try_from(reward.messages)
+				.unwrap_or_else(|_| Bounded::max_value())
+				.saturating_mul(confirmation_fee);
+			if confirmation_reward > relayer_reward {
+				confirmation_reward = relayer_reward;
+			}
+			relayer_reward = relayer_reward.saturating_sub(confirmation_reward);
+			confirmation_relayer_reward =
+				confirmation_relayer_reward.saturating_add(confirmation_reward);
+		} else {
+			// If delivery confirmation is submitted by this relayer, let's add confirmation fee
+			// from other relayers to this relayer reward.
+			confirmation_relayer_reward = confirmation_relayer_reward.saturating_add(reward.reward);
+			continue
+		}
+
+		schedule_relayer_reward::<T>(&relayer, relayer_reward);
+	}
+
+	// finally - pay reward to confirmation relayer
+	schedule_relayer_reward::<T>(confirmation_relayer, confirmation_relayer_reward);
+}
+
+/// Remember that the reward shall be paid to the relayer.
+fn schedule_relayer_reward<T: Config>(relayer: &T::AccountId, reward: T::Reward) {
+	if reward.is_zero() {
+		return
+	}
+
+	RelayerRewards::<T>::mutate(relayer, |old_reward: &mut Option<T::Reward>| {
+		let new_reward = old_reward.unwrap_or_else(Zero::zero).saturating_add(reward);
+		log::trace!(
+			target: "T::bridge-relayers",
+			"Relayer {:?} can now claim reward: {:?}",
+			relayer,
+			new_reward,
+		);
+		*old_reward = Some(new_reward);
+	});
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::*;
+
+	const RELAYER_1: AccountId = 1;
+	const RELAYER_2: AccountId = 2;
+	const RELAYER_3: AccountId = 3;
+
+	fn relayers_rewards() -> RelayersRewards<AccountId, Balance> {
+		vec![
+			(RELAYER_1, bp_messages::source_chain::RelayerRewards { reward: 100, messages: 2 }),
+			(RELAYER_2, bp_messages::source_chain::RelayerRewards { reward: 100, messages: 3 }),
+		]
+		.into_iter()
+		.collect()
+	}
+
+	#[test]
+	fn confirmation_relayer_is_rewarded_if_it_has_also_delivered_messages() {
+		run_test(|| {
+			schedule_relayers_rewards::<TestRuntime>(&RELAYER_2, relayers_rewards(), 10);
+
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_1), Some(80));
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_2), Some(120));
+		});
+	}
+
+	#[test]
+	fn confirmation_relayer_is_rewarded_if_it_has_not_delivered_any_delivered_messages() {
+		run_test(|| {
+			schedule_relayers_rewards::<TestRuntime>(&RELAYER_3, relayers_rewards(), 10);
+
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_1), Some(80));
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_2), Some(70));
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_3), Some(50));
+		});
+	}
+
+	#[test]
+	fn only_confirmation_relayer_is_rewarded_if_confirmation_fee_has_significantly_increased() {
+		run_test(|| {
+			schedule_relayers_rewards::<TestRuntime>(&RELAYER_3, relayers_rewards(), 1000);
+
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_1), None);
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_2), None);
+			assert_eq!(RelayerRewards::<TestRuntime>::get(&RELAYER_3), Some(200));
+		});
+	}
+}

bridges/modules/relayers/src/weights.rs

@@ -0,0 +1,73 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Autogenerated weights for `pallet_bridge_relayers`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-07-20, STEPS: 50, REPEAT: 20
+//! LOW RANGE: [], HIGH RANGE: []
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled
+//! CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// target/release/millau-bridge-node
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_bridge_relayers
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=Compiled
+// --heap-pages=4096
+// --output=./modules/relayers/src/weights.rs
+// --template=./.maintain/millau-weight-template.hbs
+
+#![allow(clippy::all)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{
+	traits::Get,
+	weights::{constants::RocksDbWeight, Weight},
+};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for `pallet_bridge_relayers`.
+pub trait WeightInfo {
+	fn claim_rewards() -> Weight;
+}
+
+/// Weights for `pallet_bridge_relayers` using the Millau node and recommended hardware.
+pub struct MillauWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for MillauWeight<T> {
+	fn claim_rewards() -> Weight {
+		(38_435_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	fn claim_rewards() -> Weight {
+		(38_435_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+}