Increase message fee call (#718)

* fn increase_message_fee()

* benchmarks + weights

* - extra lines

* split error

bridges/modules/message-lane/src/benchmarking.rs

@@ -81,6 +81,10 @@ pub struct MessageDeliveryProofParams<ThisChainAccountId> {
 
 /// Trait that must be implemented by runtime.
 pub trait Config<I: Instance>: crate::Config<I> {
+	/// Lane id to use in benchmarks.
+	fn bench_lane_id() -> LaneId {
+		Default::default()
+	}
 	/// Get maximal size of the message payload.
 	fn maximal_message_size() -> u32;
 	/// Return id of relayer account at the bridged chain.
@@ -121,7 +125,7 @@ benchmarks_instance! {
 	// (estimated using `send_half_maximal_message_worst_case` and `send_maximal_message_worst_case`) is
 	// added.
 	send_minimal_message_worst_case {
-		let lane_id = bench_lane_id();
+		let lane_id = T::bench_lane_id();
 		let sender = account("sender", 0, SEED);
 		T::endow_account(&sender);
 
@@ -138,7 +142,7 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(bench_lane_id()),
+			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
@@ -152,7 +156,7 @@ benchmarks_instance! {
 	// With single KB of message size, the weight of the call is increased (roughly) by
 	// `(send_16_kb_message_worst_case - send_1_kb_message_worst_case) / 15`.
 	send_1_kb_message_worst_case {
-		let lane_id = bench_lane_id();
+		let lane_id = T::bench_lane_id();
 		let sender = account("sender", 0, SEED);
 		T::endow_account(&sender);
 
@@ -175,7 +179,7 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(bench_lane_id()),
+			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
@@ -189,7 +193,7 @@ benchmarks_instance! {
 	// With single KB of message size, the weight of the call is increased (roughly) by
 	// `(send_16_kb_message_worst_case - send_1_kb_message_worst_case) / 15`.
 	send_16_kb_message_worst_case {
-		let lane_id = bench_lane_id();
+		let lane_id = T::bench_lane_id();
 		let sender = account("sender", 0, SEED);
 		T::endow_account(&sender);
 
@@ -212,11 +216,28 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(bench_lane_id()),
+			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
 
+	// Benchmark `increase_message_fee` with following conditions:
+	// * message has maximal message;
+	// * submitter account is killed because its balance is less than ED after payment.
+	increase_message_fee {
+		let sender = account("sender", 42, SEED);
+		T::endow_account(&sender);
+
+		let additional_fee = T::account_balance(&sender);
+		let lane_id = T::bench_lane_id();
+		let nonce = 1;
+
+		send_regular_message_with_payload::<T, I>(vec![42u8; T::maximal_message_size() as _]);
+	}: increase_message_fee(RawOrigin::Signed(sender.clone()), lane_id, nonce, additional_fee)
+	verify {
+		assert_eq!(T::account_balance(&sender), 0.into());
+	}
+
 	// Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following conditions:
 	// * proof does not include outbound lane state proof;
 	// * inbound lane already has state, so it needs to be read and decoded;
@@ -232,7 +253,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=21,
 			outbound_lane_data: None,
 			size: ProofSize::Minimal(EXPECTED_DEFAULT_MESSAGE_LENGTH),
@@ -240,7 +261,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -263,7 +284,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=22,
 			outbound_lane_data: None,
 			size: ProofSize::Minimal(EXPECTED_DEFAULT_MESSAGE_LENGTH),
@@ -271,7 +292,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 2, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			22,
 		);
 	}
@@ -294,7 +315,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=21,
 			outbound_lane_data: Some(OutboundLaneData {
 				oldest_unpruned_nonce: 21,
@@ -306,11 +327,11 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_confirmed_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_confirmed_nonce(T::bench_lane_id()),
 			20,
 		);
 	}
@@ -332,7 +353,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=21,
 			outbound_lane_data: None,
 			size: ProofSize::HasExtraNodes(1024),
@@ -340,7 +361,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -364,7 +385,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=21,
 			outbound_lane_data: None,
 			size: ProofSize::HasExtraNodes(16 * 1024),
@@ -372,7 +393,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -397,7 +418,7 @@ benchmarks_instance! {
 			total_messages: 1,
 		};
 		let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			inbound_lane_data: InboundLaneData {
 				relayers: vec![(1, 1, relayer_id.clone())].into_iter().collect(),
 				last_confirmed_nonce: 0,
@@ -435,7 +456,7 @@ benchmarks_instance! {
 			total_messages: 2,
 		};
 		let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			inbound_lane_data: InboundLaneData {
 				relayers: vec![(1, 2, relayer_id.clone())].into_iter().collect(),
 				last_confirmed_nonce: 0,
@@ -472,7 +493,7 @@ benchmarks_instance! {
 			total_messages: 2,
 		};
 		let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			inbound_lane_data: InboundLaneData {
 				relayers: vec![
 					(1, 1, relayer1_id.clone()),
@@ -502,7 +523,7 @@ benchmarks_instance! {
 	send_messages_of_various_lengths {
 		let i in 0..T::maximal_message_size().try_into().unwrap_or_default();
 
-		let lane_id = bench_lane_id();
+		let lane_id = T::bench_lane_id();
 		let sender = account("sender", 0, SEED);
 		T::endow_account(&sender);
 
@@ -519,7 +540,7 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(bench_lane_id()),
+			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
@@ -544,7 +565,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=(20 + i as MessageNonce),
 			outbound_lane_data: None,
 			size: ProofSize::Minimal(EXPECTED_DEFAULT_MESSAGE_LENGTH),
@@ -558,7 +579,7 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			20 + i as MessageNonce,
 		);
 	}
@@ -581,7 +602,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=21,
 			outbound_lane_data: None,
 			size: ProofSize::HasExtraNodes(i as _),
@@ -595,7 +616,7 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -618,7 +639,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=21,
 			outbound_lane_data: None,
 			size: ProofSize::HasLargeLeaf(i as _),
@@ -632,7 +653,7 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -657,7 +678,7 @@ benchmarks_instance! {
 		receive_messages::<T, I>(20);
 
 		let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			message_nonces: 21..=20 + i as MessageNonce,
 			outbound_lane_data: Some(OutboundLaneData {
 				oldest_unpruned_nonce: 21,
@@ -675,11 +696,11 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			20 + i as MessageNonce,
 		);
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_confirmed_nonce(bench_lane_id()),
+			crate::Module::<T, I>::inbound_latest_confirmed_nonce(T::bench_lane_id()),
 			20,
 		);
 	}
@@ -708,7 +729,7 @@ benchmarks_instance! {
 			total_messages: i as MessageNonce,
 		};
 		let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			inbound_lane_data: InboundLaneData {
 				relayers: vec![(1, i as MessageNonce, relayer_id.clone())].into_iter().collect(),
 				last_confirmed_nonce: 0,
@@ -750,7 +771,7 @@ benchmarks_instance! {
 			total_messages: i as MessageNonce,
 		};
 		let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
-			lane: bench_lane_id(),
+			lane: T::bench_lane_id(),
 			inbound_lane_data: InboundLaneData {
 				relayers: relayers
 					.keys()
@@ -769,25 +790,29 @@ benchmarks_instance! {
 	}
 }
 
-fn bench_lane_id() -> LaneId {
-	*b"test"
-}
-
 fn send_regular_message<T: Config<I>, I: Instance>() {
-	let mut outbound_lane = outbound_lane::<T, I>(bench_lane_id());
+	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
 	outbound_lane.send_message(MessageData {
 		payload: vec![],
 		fee: MESSAGE_FEE.into(),
 	});
 }
 
+fn send_regular_message_with_payload<T: Config<I>, I: Instance>(payload: Vec<u8>) {
+	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
+	outbound_lane.send_message(MessageData {
+		payload,
+		fee: MESSAGE_FEE.into(),
+	});
+}
+
 fn confirm_message_delivery<T: Config<I>, I: Instance>(nonce: MessageNonce) {
-	let mut outbound_lane = outbound_lane::<T, I>(bench_lane_id());
+	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
 	assert!(outbound_lane.confirm_delivery(nonce).is_some());
 }
 
 fn receive_messages<T: Config<I>, I: Instance>(nonce: MessageNonce) {
-	let mut inbound_lane_storage = inbound_lane_storage::<T, I>(bench_lane_id());
+	let mut inbound_lane_storage = inbound_lane_storage::<T, I>(T::bench_lane_id());
 	inbound_lane_storage.set_data(InboundLaneData {
 		relayers: vec![(1, nonce, T::bridged_relayer_id())].into_iter().collect(),
 		last_confirmed_nonce: 0,

bridges/modules/message-lane/src/lib.rs

@@ -42,6 +42,7 @@ pub use crate::weights_ext::{
 
 use crate::inbound_lane::{InboundLane, InboundLaneStorage};
 use crate::outbound_lane::{OutboundLane, OutboundLaneStorage};
+use crate::weights::WeightInfo;
 
 use bp_message_lane::{
 	source_chain::{LaneMessageVerifier, MessageDeliveryAndDispatchPayment, RelayersRewards, TargetHeaderChain},
@@ -173,6 +174,10 @@ decl_error! {
 		InvalidMessagesDeliveryProof,
 		/// The relayer has declared invalid unrewarded relayers state in the `receive_messages_delivery_proof` call.
 		InvalidUnrewardedRelayersState,
+		/// The message someone is trying to work with (i.e. increase fee) is already-delivered.
+		MessageIsAlreadyDelivered,
+		/// The message someone is trying to work with (i.e. increase fee) is not yet sent.
+		MessageIsNotYetSent
 	}
 }
 
@@ -348,6 +353,57 @@ decl_module! {
 			Ok(())
 		}
 
+		/// Pay additional fee for the message.
+		#[weight = T::WeightInfo::increase_message_fee()]
+		pub fn increase_message_fee(
+			origin,
+			lane_id: LaneId,
+			nonce: MessageNonce,
+			additional_fee: T::OutboundMessageFee,
+		) -> DispatchResult {
+			// if someone tries to pay for already-delivered message, we're rejecting this intention
+			// (otherwise this additional fee will be locked forever in relayers fund)
+			//
+			// if someone tries to pay for not-yet-sent message, we're rejeting this intention, or
+			// we're risking to have mess in the storage
+			let lane = outbound_lane::<T, I>(lane_id);
+			ensure!(nonce > lane.data().latest_received_nonce, Error::<T, I>::MessageIsAlreadyDelivered);
+			ensure!(nonce <= lane.data().latest_generated_nonce, Error::<T, I>::MessageIsNotYetSent);
+
+			// withdraw additional fee from submitter
+			let submitter = origin.into().map_err(|_| BadOrigin)?;
+			T::MessageDeliveryAndDispatchPayment::pay_delivery_and_dispatch_fee(
+				&submitter,
+				&additional_fee,
+				&Self::relayer_fund_account_id(),
+			).map_err(|err| {
+				frame_support::debug::trace!(
+					"Submitter {:?} can't pay additional fee {:?} for the message {:?}/{:?}: {:?}",
+					submitter,
+					additional_fee,
+					lane_id,
+					nonce,
+					err,
+				);
+
+				Error::<T, I>::FailedToWithdrawMessageFee
+			})?;
+
+			// and finally update fee in the storage
+			let message_key = MessageKey { lane_id, nonce };
+			OutboundMessages::<T, I>::mutate(message_key, |message_data| {
+				// saturating_add is fine here - overflow here means that someone controls all
+				// chain funds, which shouldn't ever happen + `pay_delivery_and_dispatch_fee`
+				// above will fail before we reach here
+				let message_data = message_data
+					.as_mut()
+					.expect("the message is sent and not yet delivered; so it is in the storage; qed");
+				message_data.fee = message_data.fee.saturating_add(&additional_fee);
+			});
+
+			Ok(())
+		}
+
 		/// Receive messages proof from bridged chain.
 		///
 		/// The weight of the call assumes that the transaction always brings outbound lane
@@ -1343,4 +1399,56 @@ mod tests {
 			);
 		});
 	}
+
+	#[test]
+	fn increase_message_fee_fails_if_message_is_already_delivered() {
+		run_test(|| {
+			send_regular_message();
+			receive_messages_delivery_proof();
+
+			assert_noop!(
+				Module::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
+				Error::<TestRuntime, DefaultInstance>::MessageIsAlreadyDelivered,
+			);
+		});
+	}
+
+	#[test]
+	fn increase_message_fee_fails_if_message_is_not_yet_sent() {
+		run_test(|| {
+			assert_noop!(
+				Module::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
+				Error::<TestRuntime, DefaultInstance>::MessageIsNotYetSent,
+			);
+		});
+	}
+
+	#[test]
+	fn increase_message_fee_fails_if_submitter_cant_pay_additional_fee() {
+		run_test(|| {
+			send_regular_message();
+
+			TestMessageDeliveryAndDispatchPayment::reject_payments();
+
+			assert_noop!(
+				Module::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
+				Error::<TestRuntime, DefaultInstance>::FailedToWithdrawMessageFee,
+			);
+		});
+	}
+
+	#[test]
+	fn increase_message_fee_succeeds() {
+		run_test(|| {
+			send_regular_message();
+
+			assert_ok!(Module::<TestRuntime, DefaultInstance>::increase_message_fee(
+				Origin::signed(1),
+				TEST_LANE_ID,
+				1,
+				100,
+			),);
+			assert!(TestMessageDeliveryAndDispatchPayment::is_fee_paid(1, 100));
+		});
+	}
 }

bridges/modules/message-lane/src/weights.rs

@@ -17,7 +17,7 @@
 //! Autogenerated weights for pallet_message_lane
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 2.0.1
-//! DATE: 2021-02-01, STEPS: [50, ], REPEAT: 20
+//! DATE: 2021-02-11, STEPS: [50, ], REPEAT: 20
 //! LOW RANGE: [], HIGH RANGE: []
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled
 //! CHAIN: Some("local"), DB CACHE: 128
@@ -51,6 +51,7 @@ pub trait WeightInfo {
 	fn send_minimal_message_worst_case() -> Weight;
 	fn send_1_kb_message_worst_case() -> Weight;
 	fn send_16_kb_message_worst_case() -> Weight;
+	fn increase_message_fee() -> Weight;
 	fn receive_single_message_proof() -> Weight;
 	fn receive_two_messages_proof() -> Weight;
 	fn receive_single_message_proof_with_outbound_lane_state() -> Weight;
@@ -72,100 +73,105 @@ pub trait WeightInfo {
 pub struct RialtoWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for RialtoWeight<T> {
 	fn send_minimal_message_worst_case() -> Weight {
-		(138_421_000 as Weight)
+		(140_645_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(4 as Weight))
 			.saturating_add(T::DbWeight::get().writes(12 as Weight))
 	}
 	fn send_1_kb_message_worst_case() -> Weight {
-		(142_633_000 as Weight)
+		(146_434_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(4 as Weight))
 			.saturating_add(T::DbWeight::get().writes(12 as Weight))
 	}
 	fn send_16_kb_message_worst_case() -> Weight {
-		(194_483_000 as Weight)
+		(214_721_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(4 as Weight))
 			.saturating_add(T::DbWeight::get().writes(12 as Weight))
 	}
+	fn increase_message_fee() -> Weight {
+		(8_395_221_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(4 as Weight))
+			.saturating_add(T::DbWeight::get().writes(3 as Weight))
+	}
 	fn receive_single_message_proof() -> Weight {
-		(154_651_000 as Weight)
+		(156_390_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_two_messages_proof() -> Weight {
-		(271_722_000 as Weight)
+		(269_316_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_single_message_proof_with_outbound_lane_state() -> Weight {
-		(170_821_000 as Weight)
+		(174_342_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_single_message_proof_1_kb() -> Weight {
-		(189_540_000 as Weight)
+		(186_621_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_single_message_proof_16_kb() -> Weight {
-		(484_899_000 as Weight)
+		(487_028_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_delivery_proof_for_single_message() -> Weight {
-		(145_328_000 as Weight)
+		(144_893_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(6 as Weight))
 			.saturating_add(T::DbWeight::get().writes(3 as Weight))
 	}
 	fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight {
-		(150_165_000 as Weight)
+		(151_134_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(7 as Weight))
 			.saturating_add(T::DbWeight::get().writes(3 as Weight))
 	}
 	fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight {
-		(215_954_000 as Weight)
+		(212_650_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(8 as Weight))
 			.saturating_add(T::DbWeight::get().writes(4 as Weight))
 	}
 	fn send_messages_of_various_lengths(i: u32) -> Weight {
-		(117_961_000 as Weight)
-			.saturating_add((3_000 as Weight).saturating_mul(i as Weight))
+		(88_670_000 as Weight)
+			.saturating_add((5_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(T::DbWeight::get().reads(4 as Weight))
 			.saturating_add(T::DbWeight::get().writes(12 as Weight))
 	}
 	fn receive_multiple_messages_proof(i: u32) -> Weight {
 		(0 as Weight)
-			.saturating_add((117_783_000 as Weight).saturating_mul(i as Weight))
+			.saturating_add((125_956_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_message_proofs_with_extra_nodes(i: u32) -> Weight {
-		(448_951_000 as Weight)
-			.saturating_add((10_000 as Weight).saturating_mul(i as Weight))
+		(462_389_000 as Weight)
+			.saturating_add((11_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_message_proofs_with_large_leaf(i: u32) -> Weight {
-		(97_174_000 as Weight)
-			.saturating_add((7_000 as Weight).saturating_mul(i as Weight))
+		(120_744_000 as Weight)
+			.saturating_add((8_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_multiple_messages_proof_with_outbound_lane_state(i: u32) -> Weight {
 		(0 as Weight)
-			.saturating_add((120_176_000 as Weight).saturating_mul(i as Weight))
+			.saturating_add((130_087_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(T::DbWeight::get().reads(3 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	fn receive_delivery_proof_for_multiple_messages_by_single_relayer(i: u32) -> Weight {
-		(132_970_000 as Weight)
-			.saturating_add((7_243_000 as Weight).saturating_mul(i as Weight))
+		(126_833_000 as Weight)
+			.saturating_add((7_793_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
 			.saturating_add(T::DbWeight::get().writes(3 as Weight))
 	}
 	fn receive_delivery_proof_for_multiple_messages_by_multiple_relayers(i: u32) -> Weight {
-		(62_936_000 as Weight)
-			.saturating_add((67_932_000 as Weight).saturating_mul(i as Weight))
+		(71_269_000 as Weight)
+			.saturating_add((72_377_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().reads((2 as Weight).saturating_mul(i as Weight)))
 			.saturating_add(T::DbWeight::get().writes(3 as Weight))
@@ -176,100 +182,105 @@ impl<T: frame_system::Config> WeightInfo for RialtoWeight<T> {
 // For backwards compatibility and tests
 impl WeightInfo for () {
 	fn send_minimal_message_worst_case() -> Weight {
-		(138_421_000 as Weight)
+		(140_645_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(12 as Weight))
 	}
 	fn send_1_kb_message_worst_case() -> Weight {
-		(142_633_000 as Weight)
+		(146_434_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(12 as Weight))
 	}
 	fn send_16_kb_message_worst_case() -> Weight {
-		(194_483_000 as Weight)
+		(214_721_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(12 as Weight))
 	}
+	fn increase_message_fee() -> Weight {
+		(8_395_221_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
+	}
 	fn receive_single_message_proof() -> Weight {
-		(154_651_000 as Weight)
+		(156_390_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_two_messages_proof() -> Weight {
-		(271_722_000 as Weight)
+		(269_316_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_single_message_proof_with_outbound_lane_state() -> Weight {
-		(170_821_000 as Weight)
+		(174_342_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_single_message_proof_1_kb() -> Weight {
-		(189_540_000 as Weight)
+		(186_621_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_single_message_proof_16_kb() -> Weight {
-		(484_899_000 as Weight)
+		(487_028_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_delivery_proof_for_single_message() -> Weight {
-		(145_328_000 as Weight)
+		(144_893_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(6 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
 	}
 	fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight {
-		(150_165_000 as Weight)
+		(151_134_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(7 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
 	}
 	fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight {
-		(215_954_000 as Weight)
+		(212_650_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(8 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
 	}
 	fn send_messages_of_various_lengths(i: u32) -> Weight {
-		(117_961_000 as Weight)
-			.saturating_add((3_000 as Weight).saturating_mul(i as Weight))
+		(88_670_000 as Weight)
+			.saturating_add((5_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(12 as Weight))
 	}
 	fn receive_multiple_messages_proof(i: u32) -> Weight {
 		(0 as Weight)
-			.saturating_add((117_783_000 as Weight).saturating_mul(i as Weight))
+			.saturating_add((125_956_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_message_proofs_with_extra_nodes(i: u32) -> Weight {
-		(448_951_000 as Weight)
-			.saturating_add((10_000 as Weight).saturating_mul(i as Weight))
+		(462_389_000 as Weight)
+			.saturating_add((11_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_message_proofs_with_large_leaf(i: u32) -> Weight {
-		(97_174_000 as Weight)
-			.saturating_add((7_000 as Weight).saturating_mul(i as Weight))
+		(120_744_000 as Weight)
+			.saturating_add((8_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_multiple_messages_proof_with_outbound_lane_state(i: u32) -> Weight {
 		(0 as Weight)
-			.saturating_add((120_176_000 as Weight).saturating_mul(i as Weight))
+			.saturating_add((130_087_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	fn receive_delivery_proof_for_multiple_messages_by_single_relayer(i: u32) -> Weight {
-		(132_970_000 as Weight)
-			.saturating_add((7_243_000 as Weight).saturating_mul(i as Weight))
+		(126_833_000 as Weight)
+			.saturating_add((7_793_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
 			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
 	}
 	fn receive_delivery_proof_for_multiple_messages_by_multiple_relayers(i: u32) -> Weight {
-		(62_936_000 as Weight)
-			.saturating_add((67_932_000 as Weight).saturating_mul(i as Weight))
+		(71_269_000 as Weight)
+			.saturating_add((72_377_000 as Weight).saturating_mul(i as Weight))
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().reads((2 as Weight).saturating_mul(i as Weight)))
 			.saturating_add(RocksDbWeight::get().writes(3 as Weight))