Adding Bridges code as git subtree. (#2515)

* Add instructions. * Squashed 'bridges/' content from commit 345e84a21 git-subtree-dir: bridges git-subtree-split: 345e84a2146b56628e9888c9f5e129cb40e868a9 * Remove bridges workspace file to avoid confusing Cargo. * Add some bridges primitives to Polkadot workspace. * Improve docs.
2026-05-30 18:41:03 +00:00 · 2021-03-01 22:33:16 +01:00
parent 7a2c7aa3fe
commit 5169155f94
291 changed files with 64249 additions and 0 deletions
@@ -0,0 +1,30 @@
+[package]
+name = "bp-message-lane"
+description = "Primitives of message lane module."
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] }
+
+# Bridge dependencies
+
+bp-runtime = { path = "../runtime", default-features = false }
+
+# Substrate Dependencies
+
+frame-support = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+frame-system = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-std = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+
+[features]
+default = ["std"]
+std = [
+	"bp-runtime/std",
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"sp-std/std"
+]
@@ -0,0 +1,228 @@
+// Copyright 2019-2020 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/>.
+
+//! Primitives of message lane module.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+// RuntimeApi generated functions
+#![allow(clippy::too_many_arguments)]
+// Generated by `DecodeLimit::decode_with_depth_limit`
+#![allow(clippy::unnecessary_mut_passed)]
+
+use codec::{Decode, Encode};
+use frame_support::RuntimeDebug;
+use sp_std::{collections::vec_deque::VecDeque, prelude::*};
+
+pub mod source_chain;
+pub mod target_chain;
+
+// Weight is reexported to avoid additional frame-support dependencies in message-lane related crates.
+pub use frame_support::weights::Weight;
+
+/// Message lane pallet parameter.
+pub trait Parameter: frame_support::Parameter {
+	/// Save parameter value in the runtime storage.
+	fn save(&self);
+}
+
+/// Lane identifier.
+pub type LaneId = [u8; 4];
+
+/// Message nonce. Valid messages will never have 0 nonce.
+pub type MessageNonce = u64;
+
+/// Message id as a tuple.
+pub type MessageId = (LaneId, MessageNonce);
+
+/// Opaque message payload. We only decode this payload when it is dispatched.
+pub type MessagePayload = Vec<u8>;
+
+/// Message key (unique message identifier) as it is stored in the storage.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug)]
+pub struct MessageKey {
+	/// ID of the message lane.
+	pub lane_id: LaneId,
+	/// Message nonce.
+	pub nonce: MessageNonce,
+}
+
+/// Message data as it is stored in the storage.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug)]
+pub struct MessageData<Fee> {
+	/// Message payload.
+	pub payload: MessagePayload,
+	/// Message delivery and dispatch fee, paid by the submitter.
+	pub fee: Fee,
+}
+
+/// Message as it is stored in the storage.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug)]
+pub struct Message<Fee> {
+	/// Message key.
+	pub key: MessageKey,
+	/// Message data.
+	pub data: MessageData<Fee>,
+}
+
+/// Inbound lane data.
+#[derive(Encode, Decode, Clone, RuntimeDebug, PartialEq, Eq)]
+pub struct InboundLaneData<RelayerId> {
+	/// Identifiers of relayers and messages that they have delivered to this lane (ordered by message nonce).
+	///
+	/// This serves as a helper storage item, to allow the source chain to easily pay rewards
+	/// to the relayers who succesfuly delivered messages to the target chain (inbound lane).
+	///
+	/// It is guaranteed to have at most N entries, where N is configured at the module level.
+	/// If there are N entries in this vec, then:
+	/// 1) all incoming messages are rejected if they're missing corresponding `proof-of(outbound-lane.state)`;
+	/// 2) all incoming messages are rejected if `proof-of(outbound-lane.state).last_delivered_nonce` is
+	///    equal to `self.last_confirmed_nonce`.
+	/// Given what is said above, all nonces in this queue are in range:
+	/// `(self.last_confirmed_nonce; self.last_delivered_nonce()]`.
+	///
+	/// When a relayer sends a single message, both of MessageNonces are the same.
+	/// When relayer sends messages in a batch, the first arg is the lowest nonce, second arg the highest nonce.
+	/// Multiple dispatches from the same relayer are allowed.
+	pub relayers: VecDeque<(MessageNonce, MessageNonce, RelayerId)>,
+
+	/// Nonce of the last message that
+	/// a) has been delivered to the target (this) chain and
+	/// b) the delivery has been confirmed on the source chain
+	///
+	/// that the target chain knows of.
+	///
+	/// This value is updated indirectly when an `OutboundLane` state of the source
+	/// chain is received alongside with new messages delivery.
+	pub last_confirmed_nonce: MessageNonce,
+}
+
+impl<RelayerId> Default for InboundLaneData<RelayerId> {
+	fn default() -> Self {
+		InboundLaneData {
+			relayers: VecDeque::new(),
+			last_confirmed_nonce: 0,
+		}
+	}
+}
+
+impl<RelayerId> InboundLaneData<RelayerId> {
+	/// Returns approximate size of the struct, given number of entries in the `relayers` set and
+	/// size of each entry.
+	///
+	/// Returns `None` if size overflows `u32` limits.
+	pub fn encoded_size_hint(relayer_id_encoded_size: u32, relayers_entries: u32) -> Option<u32> {
+		let message_nonce_size = 8;
+		let relayers_entry_size = relayer_id_encoded_size.checked_add(2 * message_nonce_size)?;
+		let relayers_size = relayers_entries.checked_mul(relayers_entry_size)?;
+		relayers_size.checked_add(message_nonce_size)
+	}
+
+	/// Nonce of the last message that has been delivered to this (target) chain.
+	pub fn last_delivered_nonce(&self) -> MessageNonce {
+		self.relayers
+			.back()
+			.map(|(_, last_nonce, _)| *last_nonce)
+			.unwrap_or(self.last_confirmed_nonce)
+	}
+}
+
+/// Gist of `InboundLaneData::relayers` field used by runtime APIs.
+#[derive(Clone, Default, Encode, Decode, RuntimeDebug, PartialEq, Eq)]
+pub struct UnrewardedRelayersState {
+	/// Number of entries in the `InboundLaneData::relayers` set.
+	pub unrewarded_relayer_entries: MessageNonce,
+	/// Number of messages in the oldest entry of `InboundLaneData::relayers`. This is the
+	/// minimal number of reward proofs required to push out this entry from the set.
+	pub messages_in_oldest_entry: MessageNonce,
+	/// Total number of messages in the relayers vector.
+	pub total_messages: MessageNonce,
+}
+
+/// Outbound lane data.
+#[derive(Encode, Decode, Clone, RuntimeDebug, PartialEq, Eq)]
+pub struct OutboundLaneData {
+	/// Nonce of oldest message that we haven't yet pruned. May point to not-yet-generated message if
+	/// all sent messages are already pruned.
+	pub oldest_unpruned_nonce: MessageNonce,
+	/// Nonce of latest message, received by bridged chain.
+	pub latest_received_nonce: MessageNonce,
+	/// Nonce of latest message, generated by us.
+	pub latest_generated_nonce: MessageNonce,
+}
+
+impl Default for OutboundLaneData {
+	fn default() -> Self {
+		OutboundLaneData {
+			// it is 1 because we're pruning everything in [oldest_unpruned_nonce; latest_received_nonce]
+			oldest_unpruned_nonce: 1,
+			latest_received_nonce: 0,
+			latest_generated_nonce: 0,
+		}
+	}
+}
+
+/// Returns total number of messages in the `InboundLaneData::relayers` vector.
+///
+/// Returns `None` if there are more messages that `MessageNonce` may fit (i.e. `MessageNonce + 1`).
+pub fn total_unrewarded_messages<RelayerId>(
+	relayers: &VecDeque<(MessageNonce, MessageNonce, RelayerId)>,
+) -> Option<MessageNonce> {
+	match (relayers.front(), relayers.back()) {
+		(Some((begin, _, _)), Some((_, end, _))) => {
+			if let Some(difference) = end.checked_sub(*begin) {
+				difference.checked_add(1)
+			} else {
+				Some(0)
+			}
+		}
+		_ => Some(0),
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn total_unrewarded_messages_does_not_overflow() {
+		assert_eq!(
+			total_unrewarded_messages(
+				&vec![(0, 0, 1), (MessageNonce::MAX, MessageNonce::MAX, 2)]
+					.into_iter()
+					.collect()
+			),
+			None,
+		);
+	}
+
+	#[test]
+	fn inbound_lane_data_returns_correct_hint() {
+		let expected_size = InboundLaneData::<u8>::encoded_size_hint(1, 13);
+		let actual_size = InboundLaneData {
+			relayers: (1u8..=13u8).map(|i| (i as _, i as _, i)).collect(),
+			last_confirmed_nonce: 13,
+		}
+		.encode()
+		.len();
+		let difference = (expected_size.unwrap() as f64 - actual_size as f64).abs();
+		assert!(
+			difference / (std::cmp::min(actual_size, expected_size.unwrap() as usize) as f64) < 0.1,
+			"Too large difference between actual ({}) and expected ({:?}) inbound lane data size",
+			actual_size,
+			expected_size,
+		);
+	}
+}
@@ -0,0 +1,192 @@
+// Copyright 2019-2020 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/>.
+
+//! Primitives of message lane module, that are used on the source chain.
+
+use crate::{InboundLaneData, LaneId, MessageNonce, OutboundLaneData};
+
+use bp_runtime::Size;
+use frame_support::{Parameter, RuntimeDebug};
+use sp_std::{collections::btree_map::BTreeMap, fmt::Debug};
+
+/// The sender of the message on the source chain.
+pub type Sender<AccountId> = frame_system::RawOrigin<AccountId>;
+
+/// Relayers rewards, grouped by relayer account id.
+pub type RelayersRewards<AccountId, Balance> = BTreeMap<AccountId, RelayerRewards<Balance>>;
+
+/// Single relayer rewards.
+#[derive(RuntimeDebug, Default)]
+pub struct RelayerRewards<Balance> {
+	/// Total rewards that are to be paid to the relayer.
+	pub reward: Balance,
+	/// Total number of messages relayed by this relayer.
+	pub messages: MessageNonce,
+}
+
+/// Target chain API. Used by source chain to verify target chain proofs.
+///
+/// All implementations of this trait should only work with finalized data that
+/// can't change. Wrong implementation may lead to invalid lane states (i.e. lane
+/// that's stuck) and/or processing messages without paying fees.
+pub trait TargetHeaderChain<Payload, AccountId> {
+	/// Error type.
+	type Error: Debug + Into<&'static str>;
+
+	/// Proof that messages have been received by target chain.
+	type MessagesDeliveryProof: Parameter + Size;
+
+	/// Verify message payload before we accept it.
+	///
+	/// **CAUTION**: this is very important function. Incorrect implementation may lead
+	/// to stuck lanes and/or relayers loses.
+	///
+	/// The proper implementation must ensure that the delivery-transaction with this
+	/// payload would (at least) be accepted into target chain transaction pool AND
+	/// eventually will be successfully 'mined'. The most obvious incorrect implementation
+	/// example would be implementation for BTC chain that accepts payloads larger than
+	/// 1MB. BTC nodes aren't accepting transactions that are larger than 1MB, so relayer
+	/// will be unable to craft valid transaction => this (and all subsequent) messages will
+	/// never be delivered.
+	fn verify_message(payload: &Payload) -> Result<(), Self::Error>;
+
+	/// Verify messages delivery proof and return lane && nonce of the latest recevied message.
+	fn verify_messages_delivery_proof(
+		proof: Self::MessagesDeliveryProof,
+	) -> Result<(LaneId, InboundLaneData<AccountId>), Self::Error>;
+}
+
+/// Lane message verifier.
+///
+/// Runtime developer may implement any additional validation logic over message-lane mechanism.
+/// E.g. if lanes should have some security (e.g. you can only accept Lane1 messages from
+/// Submitter1, Lane2 messages for those who has submitted first message to this lane, disable
+/// Lane3 until some block, ...), then it may be built using this verifier.
+///
+/// Any fee requirements should also be enforced here.
+pub trait LaneMessageVerifier<Submitter, Payload, Fee> {
+	/// Error type.
+	type Error: Debug + Into<&'static str>;
+
+	/// Verify message payload and return Ok(()) if message is valid and allowed to be sent over the lane.
+	fn verify_message(
+		submitter: &Sender<Submitter>,
+		delivery_and_dispatch_fee: &Fee,
+		lane: &LaneId,
+		outbound_data: &OutboundLaneData,
+		payload: &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 witheld 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.
+///
+/// So to be sure that any non-altruist relayer would agree to deliver message, submitter
+/// should set `delivery_and_dispatch_fee` to at least (equialent of): sum of fees from (2)
+/// to (4) above, plus some interest for the relayer.
+pub trait MessageDeliveryAndDispatchPayment<AccountId, Balance> {
+	/// Error type.
+	type Error: Debug + Into<&'static str>;
+
+	/// Withhold/write-off delivery_and_dispatch_fee from submitter account to
+	/// some relayers-fund account.
+	fn pay_delivery_and_dispatch_fee(
+		submitter: &Sender<AccountId>,
+		fee: &Balance,
+		relayer_fund_account: &AccountId,
+	) -> Result<(), Self::Error>;
+
+	/// 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(
+		confirmation_relayer: &AccountId,
+		relayers_rewards: RelayersRewards<AccountId, Balance>,
+		relayer_fund_account: &AccountId,
+	);
+
+	/// Perform some initialization in externalities-provided environment.
+	///
+	/// For instance you may ensure that particular required accounts or storage items are present.
+	/// Returns the number of storage reads performed.
+	fn initialize(_relayer_fund_account: &AccountId) -> usize {
+		0
+	}
+}
+
+/// Structure that may be used in place of `TargetHeaderChain`, `LaneMessageVerifier` and
+/// `MessageDeliveryAndDispatchPayment` on chains, where outbound messages are forbidden.
+pub struct ForbidOutboundMessages;
+
+/// Error message that is used in `ForbidOutboundMessages` implementation.
+const ALL_OUTBOUND_MESSAGES_REJECTED: &str = "This chain is configured to reject all outbound messages";
+
+impl<Payload, AccountId> TargetHeaderChain<Payload, AccountId> for ForbidOutboundMessages {
+	type Error = &'static str;
+
+	type MessagesDeliveryProof = ();
+
+	fn verify_message(_payload: &Payload) -> Result<(), Self::Error> {
+		Err(ALL_OUTBOUND_MESSAGES_REJECTED)
+	}
+
+	fn verify_messages_delivery_proof(
+		_proof: Self::MessagesDeliveryProof,
+	) -> Result<(LaneId, InboundLaneData<AccountId>), Self::Error> {
+		Err(ALL_OUTBOUND_MESSAGES_REJECTED)
+	}
+}
+
+impl<Submitter, Payload, Fee> LaneMessageVerifier<Submitter, Payload, Fee> for ForbidOutboundMessages {
+	type Error = &'static str;
+
+	fn verify_message(
+		_submitter: &Sender<Submitter>,
+		_delivery_and_dispatch_fee: &Fee,
+		_lane: &LaneId,
+		_outbound_data: &OutboundLaneData,
+		_payload: &Payload,
+	) -> Result<(), Self::Error> {
+		Err(ALL_OUTBOUND_MESSAGES_REJECTED)
+	}
+}
+
+impl<AccountId, Balance> MessageDeliveryAndDispatchPayment<AccountId, Balance> for ForbidOutboundMessages {
+	type Error = &'static str;
+
+	fn pay_delivery_and_dispatch_fee(
+		_submitter: &Sender<AccountId>,
+		_fee: &Balance,
+		_relayer_fund_account: &AccountId,
+	) -> Result<(), Self::Error> {
+		Err(ALL_OUTBOUND_MESSAGES_REJECTED)
+	}
+
+	fn pay_relayers_rewards(
+		_confirmation_relayer: &AccountId,
+		_relayers_rewards: RelayersRewards<AccountId, Balance>,
+		_relayer_fund_account: &AccountId,
+	) {
+	}
+}
@@ -0,0 +1,160 @@
+// Copyright 2019-2020 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/>.
+
+//! Primitives of message lane module, that are used on the target chain.
+
+use crate::{LaneId, Message, MessageData, MessageKey, OutboundLaneData};
+
+use bp_runtime::Size;
+use codec::{Decode, Encode, Error as CodecError};
+use frame_support::{weights::Weight, Parameter, RuntimeDebug};
+use sp_std::{collections::btree_map::BTreeMap, fmt::Debug, prelude::*};
+
+/// Proved messages from the source chain.
+pub type ProvedMessages<Message> = BTreeMap<LaneId, ProvedLaneMessages<Message>>;
+
+/// Proved messages from single lane of the source chain.
+#[derive(RuntimeDebug, Encode, Decode, Clone, PartialEq, Eq)]
+pub struct ProvedLaneMessages<Message> {
+	/// Optional outbound lane state.
+	pub lane_state: Option<OutboundLaneData>,
+	/// Messages sent through this lane.
+	pub messages: Vec<Message>,
+}
+
+/// Message data with decoded dispatch payload.
+#[derive(RuntimeDebug)]
+pub struct DispatchMessageData<DispatchPayload, Fee> {
+	/// Result of dispatch payload decoding.
+	pub payload: Result<DispatchPayload, CodecError>,
+	/// Message delivery and dispatch fee, paid by the submitter.
+	pub fee: Fee,
+}
+
+/// Message with decoded dispatch payload.
+#[derive(RuntimeDebug)]
+pub struct DispatchMessage<DispatchPayload, Fee> {
+	/// Message key.
+	pub key: MessageKey,
+	/// Message data with decoded dispatch payload.
+	pub data: DispatchMessageData<DispatchPayload, Fee>,
+}
+
+/// Source chain API. Used by target chain, to verify source chain proofs.
+///
+/// All implementations of this trait should only work with finalized data that
+/// can't change. Wrong implementation may lead to invalid lane states (i.e. lane
+/// that's stuck) and/or processing messages without paying fees.
+pub trait SourceHeaderChain<Fee> {
+	/// Error type.
+	type Error: Debug + Into<&'static str>;
+
+	/// Proof that messages are sent from source chain. This may also include proof
+	/// of corresponding outbound lane states.
+	type MessagesProof: Parameter + Size;
+
+	/// Verify messages proof and return proved messages.
+	///
+	/// Returns error if either proof is incorrect, or the number of messages in the proof
+	/// is not matching the `messages_count`.
+	///
+	/// Messages vector is required to be sorted by nonce within each lane. Out-of-order
+	/// messages will be rejected.
+	///
+	/// The `messages_count` argument verification (sane limits) is supposed to be made
+	/// outside of this function. This function only verifies that the proof declares exactly
+	/// `messages_count` messages.
+	fn verify_messages_proof(
+		proof: Self::MessagesProof,
+		messages_count: u32,
+	) -> Result<ProvedMessages<Message<Fee>>, Self::Error>;
+}
+
+/// Called when inbound message is received.
+pub trait MessageDispatch<Fee> {
+	/// Decoded message payload type. Valid message may contain invalid payload. In this case
+	/// message is delivered, but dispatch fails. Therefore, two separate types of payload
+	/// (opaque `MessagePayload` used in delivery and this `DispatchPayload` used in dispatch).
+	type DispatchPayload: Decode;
+
+	/// Estimate dispatch weight.
+	///
+	/// This function must: (1) be instant and (2) return correct upper bound
+	/// of dispatch weight.
+	fn dispatch_weight(message: &DispatchMessage<Self::DispatchPayload, Fee>) -> Weight;
+
+	/// Called when inbound message is received.
+	///
+	/// It is up to the implementers of this trait to determine whether the message
+	/// is invalid (i.e. improperly encoded, has too large weight, ...) or not.
+	fn dispatch(message: DispatchMessage<Self::DispatchPayload, Fee>);
+}
+
+impl<Message> Default for ProvedLaneMessages<Message> {
+	fn default() -> Self {
+		ProvedLaneMessages {
+			lane_state: None,
+			messages: Vec::new(),
+		}
+	}
+}
+
+impl<DispatchPayload: Decode, Fee> From<Message<Fee>> for DispatchMessage<DispatchPayload, Fee> {
+	fn from(message: Message<Fee>) -> Self {
+		DispatchMessage {
+			key: message.key,
+			data: message.data.into(),
+		}
+	}
+}
+
+impl<DispatchPayload: Decode, Fee> From<MessageData<Fee>> for DispatchMessageData<DispatchPayload, Fee> {
+	fn from(data: MessageData<Fee>) -> Self {
+		DispatchMessageData {
+			payload: DispatchPayload::decode(&mut &data.payload[..]),
+			fee: data.fee,
+		}
+	}
+}
+
+/// Structure that may be used in place of `SourceHeaderChain` and `MessageDispatch` on chains,
+/// where inbound messages are forbidden.
+pub struct ForbidInboundMessages;
+
+/// Error message that is used in `ForbidOutboundMessages` implementation.
+const ALL_INBOUND_MESSAGES_REJECTED: &str = "This chain is configured to reject all inbound messages";
+
+impl<Fee> SourceHeaderChain<Fee> for ForbidInboundMessages {
+	type Error = &'static str;
+	type MessagesProof = ();
+
+	fn verify_messages_proof(
+		_proof: Self::MessagesProof,
+		_messages_count: u32,
+	) -> Result<ProvedMessages<Message<Fee>>, Self::Error> {
+		Err(ALL_INBOUND_MESSAGES_REJECTED)
+	}
+}
+
+impl<Fee> MessageDispatch<Fee> for ForbidInboundMessages {
+	type DispatchPayload = ();
+
+	fn dispatch_weight(_message: &DispatchMessage<Self::DispatchPayload, Fee>) -> Weight {
+		Weight::MAX
+	}
+
+	fn dispatch(_message: DispatchMessage<Self::DispatchPayload, Fee>) {}
+}