New relayer rewards scheme integration (#1652)

* relayer rewards integration: initial commit

* added refund-relayer-extension to the millau runtime

* spelling

* spelling again

* new -> Default

bridges/primitives/messages/src/lib.rs

@@ -24,6 +24,7 @@ use bp_runtime::{BasicOperatingMode, OperatingMode};
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::RuntimeDebug;
 use scale_info::TypeInfo;
+use source_chain::RelayersRewards;
 use sp_core::TypeId;
 use sp_std::{collections::vec_deque::VecDeque, ops::RangeInclusive, prelude::*};
 
@@ -364,19 +365,16 @@ pub fn total_unrewarded_messages<RelayerId>(
 pub fn calc_relayers_rewards<AccountId>(
 	messages_relayers: VecDeque<UnrewardedRelayer<AccountId>>,
 	received_range: &RangeInclusive<MessageNonce>,
-) -> source_chain::RelayersRewards<AccountId>
+) -> RelayersRewards<AccountId>
 where
 	AccountId: sp_std::cmp::Ord,
 {
 	// remember to reward relayers that have delivered messages
 	// this loop is bounded by `T::MaxUnrewardedRelayerEntriesAtInboundLane` on the bridged chain
-	let mut relayers_rewards = source_chain::RelayersRewards::new();
+	let mut relayers_rewards = RelayersRewards::new();
 	for entry in messages_relayers {
 		let nonce_begin = sp_std::cmp::max(entry.messages.begin, *received_range.start());
 		let nonce_end = sp_std::cmp::min(entry.messages.end, *received_range.end());
-
-		// loop won't proceed if current entry is ahead of received range (begin > end).
-		// this loop is bound by `T::MaxUnconfirmedMessagesAtInboundLane` on the bridged chain
 		if nonce_end >= nonce_begin {
 			*relayers_rewards.entry(entry.relayer).or_default() += nonce_end - nonce_begin + 1;
 		}

bridges/primitives/messages/src/source_chain.rs

@@ -88,43 +88,6 @@ pub trait LaneMessageVerifier<SenderOrigin, Payload> {
 	) -> Result<(), Self::Error>;
 }
 
-/// Message delivery payment. It is called as a part of submit-message transaction. Transaction
-/// submitter is paying (in source chain tokens/assets) for:
-///
-/// 1) submit-message-transaction-fee itself. This fee is not included in the
-/// `delivery_and_dispatch_fee` and is withheld by the regular transaction payment mechanism;
-/// 2) message-delivery-transaction-fee. It is submitted to the target node by relayer;
-/// 3) message-dispatch fee. It is paid by relayer for processing message by target chain;
-/// 4) message-receiving-delivery-transaction-fee. It is submitted to the source node
-/// by relayer.
-pub trait MessageDeliveryAndDispatchPayment<SenderOrigin, AccountId> {
-	/// Error type.
-	type Error: Debug + Into<&'static str>;
-
-	/// Pay rewards for delivering messages to the given relayers.
-	///
-	/// The implementation may also choose to pay reward to the `confirmation_relayer`, which is
-	/// a relayer that has submitted delivery confirmation transaction.
-	fn pay_relayers_rewards(
-		lane_id: LaneId,
-		messages_relayers: VecDeque<UnrewardedRelayer<AccountId>>,
-		confirmation_relayer: &AccountId,
-		received_range: &RangeInclusive<MessageNonce>,
-	);
-}
-
-impl<SenderOrigin, AccountId> MessageDeliveryAndDispatchPayment<SenderOrigin, AccountId> for () {
-	type Error = &'static str;
-
-	fn pay_relayers_rewards(
-		_lane_id: LaneId,
-		_messages_relayers: VecDeque<UnrewardedRelayer<AccountId>>,
-		_confirmation_relayer: &AccountId,
-		_received_range: &RangeInclusive<MessageNonce>,
-	) {
-	}
-}
-
 /// Manages payments that are happening at the source chain during delivery confirmation
 /// transaction.
 pub trait DeliveryConfirmationPayments<AccountId> {
@@ -233,12 +196,10 @@ impl<SenderOrigin, Payload> LaneMessageVerifier<SenderOrigin, Payload> for Forbi
 	}
 }
 
-impl<SenderOrigin, AccountId> MessageDeliveryAndDispatchPayment<SenderOrigin, AccountId>
-	for ForbidOutboundMessages
-{
+impl<AccountId> DeliveryConfirmationPayments<AccountId> for ForbidOutboundMessages {
 	type Error = &'static str;
 
-	fn pay_relayers_rewards(
+	fn pay_reward(
 		_lane_id: LaneId,
 		_messages_relayers: VecDeque<UnrewardedRelayer<AccountId>>,
 		_confirmation_relayer: &AccountId,

bridges/primitives/messages/src/target_chain.rs

@@ -16,7 +16,7 @@
 
 //! Primitives of messages module, that are used on the target chain.
 
-use crate::{LaneId, Message, MessageKey, MessagePayload, OutboundLaneData};
+use crate::{LaneId, Message, MessageKey, MessageNonce, MessagePayload, OutboundLaneData};
 
 use bp_runtime::{messages::MessageDispatchResult, Size};
 use codec::{Decode, Encode, Error as CodecError};
@@ -112,6 +112,25 @@ pub trait MessageDispatch<AccountId> {
 	) -> MessageDispatchResult<Self::DispatchLevelResult>;
 }
 
+/// Manages payments that are happening at the target chain during message delivery transaction.
+pub trait DeliveryPayments<AccountId> {
+	/// Error type.
+	type Error: Debug + Into<&'static str>;
+
+	/// Pay rewards for delivering messages to the given relayer.
+	///
+	/// This method is called during message delivery transaction which has been submitted
+	/// by the `relayer`. The transaction brings `total_messages` messages  but only
+	/// `valid_messages` have been accepted. The post-dispatch transaction weight is the
+	/// `actual_weight`.
+	fn pay_reward(
+		relayer: AccountId,
+		total_messages: MessageNonce,
+		valid_messages: MessageNonce,
+		actual_weight: Weight,
+	);
+}
+
 impl<Message> Default for ProvedLaneMessages<Message> {
 	fn default() -> Self {
 		ProvedLaneMessages { lane_state: None, messages: Vec::new() }
@@ -130,6 +149,19 @@ impl<DispatchPayload: Decode> From<MessagePayload> for DispatchMessageData<Dispa
 	}
 }
 
+impl<AccountId> DeliveryPayments<AccountId> for () {
+	type Error = &'static str;
+
+	fn pay_reward(
+		_relayer: AccountId,
+		_total_messages: MessageNonce,
+		_valid_messages: MessageNonce,
+		_actual_weight: Weight,
+	) {
+		// this implementation is not rewarding relayer at all
+	}
+}
+
 /// Structure that may be used in place of `SourceHeaderChain` and `MessageDispatch` on chains,
 /// where inbound messages are forbidden.
 pub struct ForbidInboundMessages;