Remove message fee + message send calls (#1642)

* remove message fee * it is compiling! * fixes + fmt * more cleanup * more cleanup * restore MessageDeliveryAndDispatchPayment since we'll need relayer rewards * started rational relayer removal * more removal * removed estimate fee subcommand * remove DispatchFeePayment * more removals * removed conversion rates && some metrics * - unneeded associated type * - OutboundMessageFee * fix benchmarks compilation * fmt * test + fix benchmarks * fix send message * clippy
2026-05-31 09:51:02 +00:00 · 2022-11-18 12:24:45 +03:00
parent 1217b2cf80
commit 8c845602cf
92 changed files with 589 additions and 5796 deletions
@@ -26,10 +26,11 @@ use bp_messages::{
 		OnMessageAccepted, TargetHeaderChain,
 	},
 	target_chain::{
-		DispatchMessage, MessageDispatch, ProvedLaneMessages, ProvedMessages, SourceHeaderChain,
+		DispatchMessage, DispatchMessageData, MessageDispatch, ProvedLaneMessages, ProvedMessages,
+		SourceHeaderChain,
 	},
-	DeliveredMessages, InboundLaneData, LaneId, Message, MessageData, MessageKey, MessageNonce,
-	OutboundLaneData, Parameter as MessagesParameter, UnrewardedRelayer,
+	DeliveredMessages, InboundLaneData, LaneId, Message, MessageKey, MessageNonce, MessagePayload,
+	OutboundLaneData, UnrewardedRelayer,
 };
 use bp_runtime::{messages::MessageDispatchResult, Size};
 use codec::{Decode, Encode};
@@ -42,7 +43,7 @@ use sp_core::H256;
 use sp_runtime::{
 	testing::Header as SubstrateHeader,
 	traits::{BlakeTwo256, IdentityLookup},
-	FixedU128, Perbill,
+	Perbill,
 };
 use std::{
 	collections::{BTreeMap, VecDeque},
@@ -55,6 +56,8 @@ pub type Balance = u64;
 pub struct TestPayload {
 	/// Field that may be used to identify messages.
 	pub id: u64,
+	/// Reject this message by lane verifier?
+	pub reject_by_lane_verifier: bool,
 	/// Dispatch weight that is declared by the message sender.
 	pub declared_weight: Weight,
 	/// Message dispatch result.
@@ -140,38 +143,20 @@ parameter_types! {
 	pub const MaxMessagesToPruneAtOnce: u64 = 10;
 	pub const MaxUnrewardedRelayerEntriesAtInboundLane: u64 = 16;
 	pub const MaxUnconfirmedMessagesAtInboundLane: u64 = 32;
-	pub storage TokenConversionRate: FixedU128 = 1.into();
 	pub const TestBridgedChainId: bp_runtime::ChainId = *b"test";
 }

-#[derive(Debug, Clone, Encode, Decode, PartialEq, Eq, TypeInfo)]
-pub enum TestMessagesParameter {
-	TokenConversionRate(FixedU128),
-}
-
-impl MessagesParameter for TestMessagesParameter {
-	fn save(&self) {
-		match *self {
-			TestMessagesParameter::TokenConversionRate(conversion_rate) =>
-				TokenConversionRate::set(&conversion_rate),
-		}
-	}
-}
-
 impl Config for TestRuntime {
 	type RuntimeEvent = RuntimeEvent;
 	type WeightInfo = ();
-	type Parameter = TestMessagesParameter;
 	type MaxMessagesToPruneAtOnce = MaxMessagesToPruneAtOnce;
 	type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane;
 	type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane;

 	type MaximalOutboundPayloadSize = frame_support::traits::ConstU32<MAX_OUTBOUND_PAYLOAD_SIZE>;
 	type OutboundPayload = TestPayload;
-	type OutboundMessageFee = TestMessageFee;

 	type InboundPayload = TestPayload;
-	type InboundMessageFee = TestMessageFee;
 	type InboundRelayer = TestRelayer;

 	type TargetHeaderChain = TestTargetHeaderChain;
@@ -219,7 +204,7 @@ pub const REGULAR_PAYLOAD: TestPayload = message_payload(0, 50);
 pub const PAYLOAD_REJECTED_BY_TARGET_CHAIN: TestPayload = message_payload(1, 50);

 /// Vec of proved messages, grouped by lane.
-pub type MessagesByLaneVec = Vec<(LaneId, ProvedLaneMessages<Message<TestMessageFee>>)>;
+pub type MessagesByLaneVec = Vec<(LaneId, ProvedLaneMessages<Message>)>;

 /// Test messages proof.
 #[derive(Debug, Encode, Decode, Clone, PartialEq, Eq, TypeInfo)]
@@ -233,14 +218,12 @@ impl Size for TestMessagesProof {
 	}
 }

-impl From<Result<Vec<Message<TestMessageFee>>, ()>> for TestMessagesProof {
-	fn from(result: Result<Vec<Message<TestMessageFee>>, ()>) -> Self {
+impl From<Result<Vec<Message>, ()>> for TestMessagesProof {
+	fn from(result: Result<Vec<Message>, ()>) -> Self {
 		Self {
 			result: result.map(|messages| {
-				let mut messages_by_lane: BTreeMap<
-					LaneId,
-					ProvedLaneMessages<Message<TestMessageFee>>,
-				> = BTreeMap::new();
+				let mut messages_by_lane: BTreeMap<LaneId, ProvedLaneMessages<Message>> =
+					BTreeMap::new();
 				for message in messages {
 					messages_by_lane.entry(message.key.lane_id).or_default().messages.push(message);
 				}
@@ -288,17 +271,16 @@ impl TargetHeaderChain<TestPayload, TestRelayer> for TestTargetHeaderChain {
 #[derive(Debug, Default)]
 pub struct TestLaneMessageVerifier;

-impl LaneMessageVerifier<RuntimeOrigin, TestPayload, TestMessageFee> for TestLaneMessageVerifier {
+impl LaneMessageVerifier<RuntimeOrigin, TestPayload> for TestLaneMessageVerifier {
 	type Error = &'static str;

 	fn verify_message(
 		_submitter: &RuntimeOrigin,
-		delivery_and_dispatch_fee: &TestMessageFee,
 		_lane: &LaneId,
 		_lane_outbound_data: &OutboundLaneData,
-		_payload: &TestPayload,
+		payload: &TestPayload,
 	) -> Result<(), Self::Error> {
-		if *delivery_and_dispatch_fee != 0 {
+		if !payload.reject_by_lane_verifier {
 			Ok(())
 		} else {
 			Err(TEST_ERROR)
@@ -311,18 +293,6 @@ impl LaneMessageVerifier<RuntimeOrigin, TestPayload, TestMessageFee> for TestLan
 pub struct TestMessageDeliveryAndDispatchPayment;

 impl TestMessageDeliveryAndDispatchPayment {
-	/// Reject all payments.
-	pub fn reject_payments() {
-		frame_support::storage::unhashed::put(b":reject-message-fee:", &true);
-	}
-
-	/// Returns true if given fee has been paid by given submitter.
-	pub fn is_fee_paid(submitter: AccountId, fee: TestMessageFee) -> bool {
-		let raw_origin: Result<frame_system::RawOrigin<_>, _> =
-			RuntimeOrigin::signed(submitter).into();
-		frame_support::storage::unhashed::get(b":message-fee:") == Some((raw_origin.unwrap(), fee))
-	}
-
 	/// 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 {
@@ -331,34 +301,21 @@ impl TestMessageDeliveryAndDispatchPayment {
 	}
 }

-impl MessageDeliveryAndDispatchPayment<RuntimeOrigin, AccountId, TestMessageFee>
+impl MessageDeliveryAndDispatchPayment<RuntimeOrigin, AccountId>
 	for TestMessageDeliveryAndDispatchPayment
 {
 	type Error = &'static str;

-	fn pay_delivery_and_dispatch_fee(
-		submitter: &RuntimeOrigin,
-		fee: &TestMessageFee,
-	) -> Result<(), Self::Error> {
-		if frame_support::storage::unhashed::get(b":reject-message-fee:") == Some(true) {
-			return Err(TEST_ERROR)
-		}
-
-		let raw_origin: Result<frame_system::RawOrigin<_>, _> = submitter.clone().into();
-		frame_support::storage::unhashed::put(b":message-fee:", &(raw_origin.unwrap(), fee));
-		Ok(())
-	}
-
 	fn pay_relayers_rewards(
-		lane_id: LaneId,
+		_lane_id: LaneId,
 		message_relayers: VecDeque<UnrewardedRelayer<AccountId>>,
 		_confirmation_relayer: &AccountId,
 		received_range: &RangeInclusive<MessageNonce>,
 	) {
 		let relayers_rewards =
-			calc_relayers_rewards::<TestRuntime, ()>(lane_id, message_relayers, received_range);
+			calc_relayers_rewards::<TestRuntime, ()>(message_relayers, received_range);
 		for (relayer, reward) in &relayers_rewards {
-			let key = (b":relayer-reward:", relayer, reward.reward).encode();
+			let key = (b":relayer-reward:", relayer, reward).encode();
 			frame_support::storage::unhashed::put(&key, &true);
 		}
 	}
@@ -450,7 +407,7 @@ impl OnDeliveryConfirmed for TestOnDeliveryConfirmed2 {
 #[derive(Debug)]
 pub struct TestSourceHeaderChain;

-impl SourceHeaderChain<TestMessageFee> for TestSourceHeaderChain {
+impl SourceHeaderChain for TestSourceHeaderChain {
 	type Error = &'static str;

 	type MessagesProof = TestMessagesProof;
@@ -458,7 +415,7 @@ impl SourceHeaderChain<TestMessageFee> for TestSourceHeaderChain {
 	fn verify_messages_proof(
 		proof: Self::MessagesProof,
 		_messages_count: u32,
-	) -> Result<ProvedMessages<Message<TestMessageFee>>, Self::Error> {
+	) -> Result<ProvedMessages<Message>, Self::Error> {
 		proof.result.map(|proof| proof.into_iter().collect()).map_err(|_| TEST_ERROR)
 	}
 }
@@ -467,10 +424,10 @@ impl SourceHeaderChain<TestMessageFee> for TestSourceHeaderChain {
 #[derive(Debug)]
 pub struct TestMessageDispatch;

-impl MessageDispatch<AccountId, TestMessageFee> for TestMessageDispatch {
+impl MessageDispatch<AccountId> for TestMessageDispatch {
 	type DispatchPayload = TestPayload;

-	fn dispatch_weight(message: &mut DispatchMessage<TestPayload, TestMessageFee>) -> Weight {
+	fn dispatch_weight(message: &mut DispatchMessage<TestPayload>) -> Weight {
 		match message.data.payload.as_ref() {
 			Ok(payload) => payload.declared_weight,
 			Err(_) => Weight::from_ref_time(0),
@@ -479,7 +436,7 @@ impl MessageDispatch<AccountId, TestMessageFee> for TestMessageDispatch {

 	fn dispatch(
 		_relayer_account: &AccountId,
-		message: DispatchMessage<TestPayload, TestMessageFee>,
+		message: DispatchMessage<TestPayload>,
 	) -> MessageDispatchResult {
 		match message.data.payload.as_ref() {
 			Ok(payload) => payload.dispatch_result.clone(),
@@ -489,25 +446,31 @@ impl MessageDispatch<AccountId, TestMessageFee> for TestMessageDispatch {
 }

 /// Return test lane message with given nonce and payload.
-pub fn message(nonce: MessageNonce, payload: TestPayload) -> Message<TestMessageFee> {
-	Message { key: MessageKey { lane_id: TEST_LANE_ID, nonce }, data: message_data(payload) }
+pub fn message(nonce: MessageNonce, payload: TestPayload) -> Message {
+	Message { key: MessageKey { lane_id: TEST_LANE_ID, nonce }, payload: payload.encode() }
+}
+
+/// Return valid outbound message data, constructed from given payload.
+pub fn outbound_message_data(payload: TestPayload) -> MessagePayload {
+	payload.encode()
+}
+
+/// Return valid inbound (dispatch) message data, constructed from given payload.
+pub fn inbound_message_data(payload: TestPayload) -> DispatchMessageData<TestPayload> {
+	DispatchMessageData { payload: Ok(payload) }
 }

 /// Constructs message payload using given arguments and zero unspent weight.
 pub const fn message_payload(id: u64, declared_weight: u64) -> TestPayload {
 	TestPayload {
 		id,
+		reject_by_lane_verifier: false,
 		declared_weight: Weight::from_ref_time(declared_weight),
 		dispatch_result: dispatch_result(0),
 		extra: Vec::new(),
 	}
 }

-/// Return message data with valid fee for given payload.
-pub fn message_data(payload: TestPayload) -> MessageData<TestMessageFee> {
-	MessageData { payload: payload.encode(), fee: 1 }
-}
-
 /// Returns message dispatch result with given unspent weight.
 pub const fn dispatch_result(unspent_weight: u64) -> MessageDispatchResult {
 	MessageDispatchResult {