diff --git a/bridges/bin/millau/runtime/src/lib.rs b/bridges/bin/millau/runtime/src/lib.rs index 09171dd640c60..dcb76fc32eb12 100644 --- a/bridges/bin/millau/runtime/src/lib.rs +++ b/bridges/bin/millau/runtime/src/lib.rs @@ -471,15 +471,15 @@ impl pallet_bridge_messages::Config for Runtime { type InboundPayload = crate::rialto_messages::FromRialtoMessagePayload; type InboundRelayer = bp_rialto::AccountId; + type DeliveryPayments = (); type TargetHeaderChain = crate::rialto_messages::Rialto; type LaneMessageVerifier = crate::rialto_messages::ToRialtoMessageVerifier; - type MessageDeliveryAndDispatchPayment = - pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< - Runtime, - frame_support::traits::ConstU64<100_000>, - frame_support::traits::ConstU64<100_000>, - >; + type DeliveryConfirmationPayments = pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< + Runtime, + frame_support::traits::ConstU64<100_000>, + frame_support::traits::ConstU64<100_000>, + >; type SourceHeaderChain = crate::rialto_messages::Rialto; type MessageDispatch = crate::rialto_messages::FromRialtoMessageDispatch; @@ -502,15 +502,15 @@ impl pallet_bridge_messages::Config for Run type InboundPayload = crate::rialto_parachain_messages::FromRialtoParachainMessagePayload; type InboundRelayer = bp_rialto_parachain::AccountId; + type DeliveryPayments = (); type TargetHeaderChain = crate::rialto_parachain_messages::RialtoParachain; type LaneMessageVerifier = crate::rialto_parachain_messages::ToRialtoParachainMessageVerifier; - type MessageDeliveryAndDispatchPayment = - pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< - Runtime, - frame_support::traits::ConstU64<100_000>, - frame_support::traits::ConstU64<100_000>, - >; + type DeliveryConfirmationPayments = pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< + Runtime, + frame_support::traits::ConstU64<100_000>, + frame_support::traits::ConstU64<100_000>, + >; type SourceHeaderChain = crate::rialto_parachain_messages::RialtoParachain; type MessageDispatch = crate::rialto_parachain_messages::FromRialtoParachainMessageDispatch; @@ -518,6 +518,8 @@ impl pallet_bridge_messages::Config for Run } parameter_types! { + pub const RialtoParachainMessagesLane: bp_messages::LaneId = rialto_parachain_messages::XCM_LANE; + pub const RialtoParachainId: u32 = bp_rialto_parachain::RIALTO_PARACHAIN_ID; pub const RialtoParasPalletName: &'static str = bp_rialto::PARAS_PALLET_NAME; pub const WestendParasPalletName: &'static str = bp_westend::PARAS_PALLET_NAME; pub const MaxRialtoParaHeadSize: u32 = bp_rialto::MAX_NESTED_PARACHAIN_HEAD_SIZE; @@ -613,6 +615,19 @@ generate_bridge_reject_obsolete_headers_and_messages! { BridgeRialtoMessages, BridgeRialtoParachainMessages } +/// Signed extension that refunds relayers that are delivering messages from the Rialto parachain. +pub type BridgeRefundRialtoParachainRelayers = + bridge_runtime_common::refund_relayer_extension::RefundRelayerForMessagesFromParachain< + Runtime, + RialtoGrandpaInstance, + WithRialtoParachainsInstance, + WithRialtoParachainMessagesInstance, + BridgeRejectObsoleteHeadersAndMessages, + RialtoParachainId, + RialtoParachainMessagesLane, + Runtime, + >; + /// The address format for describing accounts. pub type Address = AccountId; /// Block header type as expected by this runtime. @@ -634,6 +649,7 @@ pub type SignedExtra = ( frame_system::CheckWeight, pallet_transaction_payment::ChargeTransactionPayment, BridgeRejectObsoleteHeadersAndMessages, + BridgeRefundRialtoParachainRelayers, ); /// The payload being signed in transactions. pub type SignedPayload = generic::SignedPayload; diff --git a/bridges/bin/rialto-parachain/runtime/src/lib.rs b/bridges/bin/rialto-parachain/runtime/src/lib.rs index fd667af738a3e..6a936bd9f0775 100644 --- a/bridges/bin/rialto-parachain/runtime/src/lib.rs +++ b/bridges/bin/rialto-parachain/runtime/src/lib.rs @@ -566,15 +566,15 @@ impl pallet_bridge_messages::Config for Runtime { type InboundPayload = crate::millau_messages::FromMillauMessagePayload; type InboundRelayer = bp_millau::AccountId; + type DeliveryPayments = (); type TargetHeaderChain = crate::millau_messages::Millau; type LaneMessageVerifier = crate::millau_messages::ToMillauMessageVerifier; - type MessageDeliveryAndDispatchPayment = - pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< - Runtime, - frame_support::traits::ConstU64<100_000>, - frame_support::traits::ConstU64<100_000>, - >; + type DeliveryConfirmationPayments = pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< + Runtime, + frame_support::traits::ConstU128<100_000>, + frame_support::traits::ConstU128<100_000>, + >; type SourceHeaderChain = crate::millau_messages::Millau; type MessageDispatch = crate::millau_messages::FromMillauMessageDispatch; diff --git a/bridges/bin/rialto/runtime/src/lib.rs b/bridges/bin/rialto/runtime/src/lib.rs index 93e2ad92c18d9..355ccc0b00282 100644 --- a/bridges/bin/rialto/runtime/src/lib.rs +++ b/bridges/bin/rialto/runtime/src/lib.rs @@ -453,15 +453,15 @@ impl pallet_bridge_messages::Config for Runtime { type InboundPayload = crate::millau_messages::FromMillauMessagePayload; type InboundRelayer = bp_millau::AccountId; + type DeliveryPayments = (); type TargetHeaderChain = crate::millau_messages::Millau; type LaneMessageVerifier = crate::millau_messages::ToMillauMessageVerifier; - type MessageDeliveryAndDispatchPayment = - pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< - Runtime, - frame_support::traits::ConstU64<100_000>, - frame_support::traits::ConstU64<100_000>, - >; + type DeliveryConfirmationPayments = pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< + Runtime, + frame_support::traits::ConstU128<100_000>, + frame_support::traits::ConstU128<100_000>, + >; type SourceHeaderChain = crate::millau_messages::Millau; type MessageDispatch = crate::millau_messages::FromMillauMessageDispatch; diff --git a/bridges/bin/runtime-common/src/refund_relayer_extension.rs b/bridges/bin/runtime-common/src/refund_relayer_extension.rs index cb3448d3dd4cd..6b6e2078e0022 100644 --- a/bridges/bin/runtime-common/src/refund_relayer_extension.rs +++ b/bridges/bin/runtime-common/src/refund_relayer_extension.rs @@ -33,7 +33,7 @@ use codec::{Decode, Encode}; use frame_support::{ dispatch::{CallableCallFor, DispatchInfo, Dispatchable, PostDispatchInfo}, traits::IsSubType, - CloneNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound, + CloneNoBound, DefaultNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound, }; use pallet_bridge_grandpa::{ BridgedChain, Call as GrandpaCall, Config as GrandpaConfig, Pallet as GrandpaPallet, @@ -95,7 +95,14 @@ where /// /// Extension does not refund transaction tip due to security reasons. #[derive( - CloneNoBound, Decode, Encode, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound, TypeInfo, + CloneNoBound, + Decode, + DefaultNoBound, + Encode, + EqNoBound, + PartialEqNoBound, + RuntimeDebugNoBound, + TypeInfo, )] #[scale_info(skip_type_params(RT, GI, PI, MI, BE, PID, LID, FEE))] #[allow(clippy::type_complexity)] // TODO: get rid of that in https://github.com/paritytech/parity-bridges-common/issues/1666 diff --git a/bridges/modules/messages/src/lib.rs b/bridges/modules/messages/src/lib.rs index 8e394c6bcea33..f2d7f4c728cac 100644 --- a/bridges/modules/messages/src/lib.rs +++ b/bridges/modules/messages/src/lib.rs @@ -52,11 +52,11 @@ use crate::{ use bp_messages::{ source_chain::{ - LaneMessageVerifier, MessageDeliveryAndDispatchPayment, SendMessageArtifacts, - TargetHeaderChain, + DeliveryConfirmationPayments, LaneMessageVerifier, SendMessageArtifacts, TargetHeaderChain, }, target_chain::{ - DispatchMessage, MessageDispatch, ProvedLaneMessages, ProvedMessages, SourceHeaderChain, + DeliveryPayments, DispatchMessage, MessageDispatch, ProvedLaneMessages, ProvedMessages, + SourceHeaderChain, }, total_unrewarded_messages, DeliveredMessages, InboundLaneData, InboundMessageDetails, LaneId, MessageKey, MessageNonce, MessagePayload, MessagesOperatingMode, OutboundLaneData, @@ -143,6 +143,8 @@ pub mod pallet { /// Identifier of relayer that deliver messages to this chain. Relayer reward is paid on the /// bridged chain. type InboundRelayer: Parameter + MaxEncodedLen; + /// Delivery payments. + type DeliveryPayments: DeliveryPayments; // Types that are used by outbound_lane (on source chain). @@ -150,11 +152,8 @@ pub mod pallet { type TargetHeaderChain: TargetHeaderChain; /// Message payload verifier. type LaneMessageVerifier: LaneMessageVerifier; - /// Message delivery payment. - type MessageDeliveryAndDispatchPayment: MessageDeliveryAndDispatchPayment< - Self::RuntimeOrigin, - Self::AccountId, - >; + /// Delivery confirmation payments. + type DeliveryConfirmationPayments: DeliveryConfirmationPayments; // Types that are used by inbound_lane (on target chain). @@ -377,9 +376,17 @@ pub mod pallet { messages_received_status.push(lane_messages_received_status); } + // let's now deal with relayer payments + T::DeliveryPayments::pay_reward( + relayer_id_at_this_chain, + total_messages, + valid_messages, + actual_weight, + ); + log::debug!( target: LOG_TARGET, - "Received messages: total={}, valid={}. Weight used: {}/{}", + "Received messages: total={}, valid={}. Weight used: {}/{}.", total_messages, valid_messages, actual_weight, @@ -388,7 +395,7 @@ pub mod pallet { Self::deposit_event(Event::MessagesReceived(messages_received_status)); - Ok(PostDispatchInfo { actual_weight: Some(actual_weight), pays_fee: Pays::Yes }) + Ok(PostDispatchInfo { actual_weight: Some(actual_weight), pays_fee: Pays::No }) } /// Receive messages delivery proof from bridged chain. @@ -475,7 +482,7 @@ pub mod pallet { }); // if some new messages have been confirmed, reward relayers - >::MessageDeliveryAndDispatchPayment::pay_relayers_rewards( + T::DeliveryConfirmationPayments::pay_reward( lane_id, lane_data.relayers, &confirmation_relayer, @@ -879,10 +886,10 @@ mod tests { use super::*; use crate::mock::{ message, message_payload, run_test, unrewarded_relayer, DbWeight, - RuntimeEvent as TestEvent, RuntimeOrigin, TestMessageDeliveryAndDispatchPayment, - TestMessagesDeliveryProof, TestMessagesProof, TestRuntime, MAX_OUTBOUND_PAYLOAD_SIZE, - PAYLOAD_REJECTED_BY_TARGET_CHAIN, REGULAR_PAYLOAD, TEST_LANE_ID, TEST_LANE_ID_2, - TEST_LANE_ID_3, TEST_RELAYER_A, TEST_RELAYER_B, + RuntimeEvent as TestEvent, RuntimeOrigin, TestDeliveryConfirmationPayments, + TestDeliveryPayments, TestMessagesDeliveryProof, TestMessagesProof, TestRuntime, + MAX_OUTBOUND_PAYLOAD_SIZE, PAYLOAD_REJECTED_BY_TARGET_CHAIN, REGULAR_PAYLOAD, TEST_LANE_ID, + TEST_LANE_ID_2, TEST_LANE_ID_3, TEST_RELAYER_A, TEST_RELAYER_B, }; use bp_messages::{UnrewardedRelayer, UnrewardedRelayersState}; use bp_test_utils::generate_owned_bridge_module_tests; @@ -1165,6 +1172,8 @@ mod tests { )); assert_eq!(InboundLanes::::get(TEST_LANE_ID).0.last_delivered_nonce(), 1); + + assert!(TestDeliveryPayments::is_reward_paid(1)); }); } @@ -1326,8 +1335,8 @@ mod tests { ..Default::default() }, )); - assert!(TestMessageDeliveryAndDispatchPayment::is_reward_paid(TEST_RELAYER_A, 1)); - assert!(!TestMessageDeliveryAndDispatchPayment::is_reward_paid(TEST_RELAYER_B, 1)); + assert!(TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_A, 1)); + assert!(!TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_B, 1)); // this reports delivery of both message 1 and message 2 => reward is paid only to // TEST_RELAYER_B @@ -1352,8 +1361,8 @@ mod tests { ..Default::default() }, )); - assert!(!TestMessageDeliveryAndDispatchPayment::is_reward_paid(TEST_RELAYER_A, 1)); - assert!(TestMessageDeliveryAndDispatchPayment::is_reward_paid(TEST_RELAYER_B, 1)); + assert!(!TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_A, 1)); + assert!(TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_B, 1)); }); } diff --git a/bridges/modules/messages/src/mock.rs b/bridges/modules/messages/src/mock.rs index 599d3a6b3793c..3f38d923b280c 100644 --- a/bridges/modules/messages/src/mock.rs +++ b/bridges/modules/messages/src/mock.rs @@ -21,10 +21,10 @@ use crate::Config; use bp_messages::{ calc_relayers_rewards, - source_chain::{LaneMessageVerifier, MessageDeliveryAndDispatchPayment, TargetHeaderChain}, + source_chain::{DeliveryConfirmationPayments, LaneMessageVerifier, TargetHeaderChain}, target_chain::{ - DispatchMessage, DispatchMessageData, MessageDispatch, ProvedLaneMessages, ProvedMessages, - SourceHeaderChain, + DeliveryPayments, DispatchMessage, DispatchMessageData, MessageDispatch, + ProvedLaneMessages, ProvedMessages, SourceHeaderChain, }, DeliveredMessages, InboundLaneData, LaneId, Message, MessageKey, MessageNonce, MessagePayload, OutboundLaneData, UnrewardedRelayer, @@ -154,10 +154,11 @@ impl Config for TestRuntime { type InboundPayload = TestPayload; type InboundRelayer = TestRelayer; + type DeliveryPayments = TestDeliveryPayments; type TargetHeaderChain = TestTargetHeaderChain; type LaneMessageVerifier = TestLaneMessageVerifier; - type MessageDeliveryAndDispatchPayment = TestMessageDeliveryAndDispatchPayment; + type DeliveryConfirmationPayments = TestDeliveryConfirmationPayments; type SourceHeaderChain = TestSourceHeaderChain; type MessageDispatch = TestMessageDispatch; @@ -288,11 +289,38 @@ impl LaneMessageVerifier for TestLaneMessageVerifier } } -/// Message fee payment system that is used in tests. +/// Reward payments at the target chain during delivery transaction. #[derive(Debug, Default)] -pub struct TestMessageDeliveryAndDispatchPayment; +pub struct TestDeliveryPayments; -impl TestMessageDeliveryAndDispatchPayment { +impl TestDeliveryPayments { + /// Returns true if given relayer has been rewarded with given balance. The reward-paid flag is + /// cleared after the call. + pub fn is_reward_paid(relayer: AccountId) -> bool { + let key = (b":delivery-relayer-reward:", relayer).encode(); + frame_support::storage::unhashed::take::(&key).is_some() + } +} + +impl DeliveryPayments for TestDeliveryPayments { + type Error = &'static str; + + fn pay_reward( + relayer: AccountId, + _total_messages: MessageNonce, + _valid_messages: MessageNonce, + _actual_weight: Weight, + ) { + let key = (b":delivery-relayer-reward:", relayer).encode(); + frame_support::storage::unhashed::put(&key, &true); + } +} + +/// Reward payments at the source chain during delivery confirmation transaction. +#[derive(Debug, Default)] +pub struct TestDeliveryConfirmationPayments; + +impl TestDeliveryConfirmationPayments { /// Returns true if given relayer has been rewarded with given balance. The reward-paid flag is /// cleared after the call. pub fn is_reward_paid(relayer: AccountId, fee: TestMessageFee) -> bool { @@ -301,18 +329,16 @@ impl TestMessageDeliveryAndDispatchPayment { } } -impl MessageDeliveryAndDispatchPayment - for TestMessageDeliveryAndDispatchPayment -{ +impl DeliveryConfirmationPayments for TestDeliveryConfirmationPayments { type Error = &'static str; - fn pay_relayers_rewards( + fn pay_reward( _lane_id: LaneId, - message_relayers: VecDeque>, + messages_relayers: VecDeque>, _confirmation_relayer: &AccountId, received_range: &RangeInclusive, ) { - let relayers_rewards = calc_relayers_rewards(message_relayers, received_range); + let relayers_rewards = calc_relayers_rewards(messages_relayers, received_range); for (relayer, reward) in &relayers_rewards { let key = (b":relayer-reward:", relayer, reward).encode(); frame_support::storage::unhashed::put(&key, &true); diff --git a/bridges/modules/relayers/src/payment_adapter.rs b/bridges/modules/relayers/src/payment_adapter.rs index 750f3397e74b7..946b31cf7af41 100644 --- a/bridges/modules/relayers/src/payment_adapter.rs +++ b/bridges/modules/relayers/src/payment_adapter.rs @@ -14,14 +14,11 @@ // You should have received a copy of the GNU General Public License // along with Parity Bridges Common. If not, see . -//! Code that allows relayers pallet to be used as a delivery+dispatch payment mechanism -//! for the messages pallet. +//! Code that allows relayers pallet to be used as a payment mechanism for the messages pallet. use crate::{Config, Pallet}; -use bp_messages::source_chain::{ - DeliveryConfirmationPayments, MessageDeliveryAndDispatchPayment, RelayersRewards, -}; +use bp_messages::source_chain::{DeliveryConfirmationPayments, RelayersRewards}; 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}; @@ -32,34 +29,6 @@ pub struct DeliveryConfirmationPaymentsAdapter, ); -// TODO (https://github.com/paritytech/parity-bridges-common/pull/1652): this impl must be removed -impl - MessageDeliveryAndDispatchPayment - for DeliveryConfirmationPaymentsAdapter -where - T: Config, -{ - type Error = &'static str; - - fn pay_relayers_rewards( - lane_id: bp_messages::LaneId, - messages_relayers: VecDeque>, - confirmation_relayer: &T::AccountId, - received_range: &RangeInclusive, - ) { - let relayers_rewards = - bp_messages::calc_relayers_rewards::(messages_relayers, received_range); - - register_relayers_rewards::( - confirmation_relayer, - relayers_rewards, - lane_id, - 100_000_u32.into(), - 10_000_u32.into(), - ); - } -} - impl DeliveryConfirmationPayments for DeliveryConfirmationPaymentsAdapter where diff --git a/bridges/primitives/messages/src/lib.rs b/bridges/primitives/messages/src/lib.rs index c288323f94159..e4f3cb5998b6c 100644 --- a/bridges/primitives/messages/src/lib.rs +++ b/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( pub fn calc_relayers_rewards( messages_relayers: VecDeque>, received_range: &RangeInclusive, -) -> source_chain::RelayersRewards +) -> RelayersRewards 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; } diff --git a/bridges/primitives/messages/src/source_chain.rs b/bridges/primitives/messages/src/source_chain.rs index 337fd05251764..d5d7549099c31 100644 --- a/bridges/primitives/messages/src/source_chain.rs +++ b/bridges/primitives/messages/src/source_chain.rs @@ -88,43 +88,6 @@ pub trait LaneMessageVerifier { ) -> 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 { - /// 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>, - confirmation_relayer: &AccountId, - received_range: &RangeInclusive, - ); -} - -impl MessageDeliveryAndDispatchPayment for () { - type Error = &'static str; - - fn pay_relayers_rewards( - _lane_id: LaneId, - _messages_relayers: VecDeque>, - _confirmation_relayer: &AccountId, - _received_range: &RangeInclusive, - ) { - } -} - /// Manages payments that are happening at the source chain during delivery confirmation /// transaction. pub trait DeliveryConfirmationPayments { @@ -233,12 +196,10 @@ impl LaneMessageVerifier for Forbi } } -impl MessageDeliveryAndDispatchPayment - for ForbidOutboundMessages -{ +impl DeliveryConfirmationPayments for ForbidOutboundMessages { type Error = &'static str; - fn pay_relayers_rewards( + fn pay_reward( _lane_id: LaneId, _messages_relayers: VecDeque>, _confirmation_relayer: &AccountId, diff --git a/bridges/primitives/messages/src/target_chain.rs b/bridges/primitives/messages/src/target_chain.rs index 1a3daad404388..1b285b065aa27 100644 --- a/bridges/primitives/messages/src/target_chain.rs +++ b/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 { ) -> MessageDispatchResult; } +/// Manages payments that are happening at the target chain during message delivery transaction. +pub trait DeliveryPayments { + /// 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 Default for ProvedLaneMessages { fn default() -> Self { ProvedLaneMessages { lane_state: None, messages: Vec::new() } @@ -130,6 +149,19 @@ impl From for DispatchMessageData DeliveryPayments 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; diff --git a/bridges/relays/client-millau/src/lib.rs b/bridges/relays/client-millau/src/lib.rs index f8b350d3d0c2e..023d93fb72d92 100644 --- a/bridges/relays/client-millau/src/lib.rs +++ b/bridges/relays/client-millau/src/lib.rs @@ -114,6 +114,7 @@ impl ChainWithTransactions for Millau { frame_system::CheckWeight::::new(), pallet_transaction_payment::ChargeTransactionPayment::::from(unsigned.tip), millau_runtime::BridgeRejectObsoleteHeadersAndMessages, + millau_runtime::BridgeRefundRialtoParachainRelayers::default(), ), ( (), @@ -125,6 +126,7 @@ impl ChainWithTransactions for Millau { (), (), (), + () ), ); let signature = raw_payload.using_encoded(|payload| param.signer.sign(payload));