Add HrmpChannelManagementHooks

runtime/parachains/src/hrmp.rs

@@ -31,6 +31,7 @@ use sp_std::{
 	fmt, mem,
 	prelude::*,
 };
+use xcm::v0::{Result as XcmResult, ExecuteHrmp};
 
 pub use pallet::*;
 
@@ -467,6 +468,23 @@ pub mod pallet {
 	}
 }
 
+impl<T: Config> ExecuteHrmp for Module<T> {
+	fn hrmp_init_open_channel(sender: u32, recipient: u32, max_message_size: u32, max_capacity: u32) -> XcmResult {
+		Self::init_open_channel(sender.into(), recipient.into(), max_capacity, max_message_size).map_err(|_| ().into())
+	}
+	fn hrmp_accept_open_channel(recipient: u32, sender: u32) -> XcmResult {
+		Self::accept_open_channel(recipient.into(), sender.into()).map_err(|_| ().into())
+	}
+	fn hrmp_close_channel(initiator: u32, sender: u32, recipient: u32) -> XcmResult {
+		Self::close_channel(initiator.into(), 
+			HrmpChannelId { 
+				sender: sender.into(),
+				recipient: recipient.into(),
+			}
+		).map_err(|_| ().into())
+	}
+}
+
 #[cfg(feature = "std")]
 fn initialize_storage<T: Config>(preopen_hrmp_channels: &[(ParaId, ParaId, u32, u32)]) {
 	let host_config = configuration::Pallet::<T>::config();

runtime/rococo/src/lib.rs

@@ -668,6 +668,7 @@ impl xcm_executor::Config for XcmConfig {
 	type Call = Call;
 	type XcmSender = XcmRouter;
 	type AssetTransactor = LocalAssetTransactor;
+	type HrmpExecutor = Hrmp;
 	type OriginConverter = LocalOriginConverter;
 	type IsReserve = ();
 	type IsTeleporter = TrustedTeleporters;

xcm/src/v0/mod.rs

@@ -262,6 +262,52 @@ pub enum Xcm<Call> {
 		recipient: u32,
 	},
 
+	/// A message to propose opening a channel on the relay-chain between the
+	/// sender para to the recipient para.
+	///
+	/// - `recipient`: The recipient in the to-be opened channel.
+	/// - `max_message_size`: The maximum size of a message proposed by the sender.
+	/// - `max_capacity`: The maximum number of messages that can be queued in the channel.
+	///
+	/// Safety: The message should originate directly from the sender para.
+	///
+	/// Kind: *Instruction*.
+	///
+	/// Errors:
+	HrmpInitOpenChannel {
+		#[codec(compact)] recipient: u32,
+		#[codec(compact)] max_message_size: u32,
+		#[codec(compact)] max_capacity: u32,
+	},
+
+	/// A message to accept opening a channel on the relay-chain.
+	///
+	/// - `sender`: The sender in the to-be opened channel.
+	///
+	/// Safety: The message should originate directly from the recipient para.
+	///
+	/// Kind: *Instruction*.
+	///
+	/// Errors:
+	HrmpAcceptOpenChannel {
+		#[codec(compact)] sender: u32,
+	},
+
+	/// A message to close a channel on the relay-chain.
+	///
+	/// - `sender`: The sender in the to-be closed channel.
+	/// - `recipient`: The recipient in the to-be closed channel.
+	///
+	/// Safety: The message should originate directly from the sender or
+	/// recipient para (either member of the channel).
+	///
+	/// Kind: *Instruction*.
+	///
+	/// Errors:
+	HrmpCloseChannel {
+		#[codec(compact)] sender: u32,
+		#[codec(compact)] recipient: u32,
+	},
 	/// A message to indicate that the embedded XCM is actually arriving on behalf of some consensus
 	/// location within the origin.
 	///

xcm/src/v0/traits.rs

@@ -259,3 +259,21 @@ impl SendXcm for Tuple {
 		Err(Error::CannotReachDestination(destination, message))
 	}
 }
+
+pub trait ExecuteHrmp {
+	fn hrmp_init_open_channel(sender: u32, recipient: u32, max_message_size: u32, max_capacity: u32) -> Result;
+	fn hrmp_accept_open_channel(recipient: u32, sender: u32) -> Result;
+	fn hrmp_close_channel(initiator: u32, sender: u32, recipient: u32) -> Result;
+}
+
+impl ExecuteHrmp for () {
+	fn hrmp_init_open_channel(_sender: u32, _recipient: u32, _max_message_size: u32, _max_capacity: u32) -> Result {
+		Err(().into())
+	}
+	fn hrmp_accept_open_channel(_recipient: u32, _sender: u32) -> Result {
+		Err(().into())
+	}
+	fn hrmp_close_channel(_initiator: u32, _sender: u32, _recipient: u32) -> Result {
+		Err(().into())
+	}
+}

xcm/xcm-executor/src/config.rs

@@ -22,7 +22,7 @@ use frame_support::{
 	dispatch::{Dispatchable, Parameter},
 	weights::{GetDispatchInfo, PostDispatchInfo},
 };
-use xcm::v0::SendXcm;
+use xcm::v0::{SendXcm, ExecuteHrmp};
 
 /// The trait to parameterize the `XcmExecutor`.
 pub trait Config {
@@ -35,6 +35,9 @@ pub trait Config {
 	/// How to withdraw and deposit an asset.
 	type AssetTransactor: TransactAsset;
 
+	/// How to execute HRMP-related actions
+	type HrmpExecutor: ExecuteHrmp; 
+
 	/// How to get a call origin from a `OriginKind` value.
 	type OriginConverter: ConvertOrigin<<Self::Call as Dispatchable>::Origin>;
 

xcm/xcm-executor/src/lib.rs

@@ -234,6 +234,31 @@ impl<Config: config::Config> XcmExecutor<Config> {
 				// execution has taken.
 				None
 			},
+			(origin, Xcm::HrmpInitOpenChannel { recipient, max_message_size, max_capacity } ) => {
+				let sender = match origin {
+					MultiLocation::X1(Junction::Parachain { id }) => id,
+					_ => Err(XcmError::BadOrigin)?,
+				};
+				return Config::HrmpExecutor::hrmp_init_open_channel(sender, recipient, max_message_size, max_capacity)
+			}
+			(origin, Xcm::HrmpAcceptOpenChannel { sender } ) => {
+				let recipient = match origin {
+					MultiLocation::X1(Junction::Parachain { id }) => id,
+					_ => Err(XcmError::BadOrigin)?,
+				};
+				return Config::HrmpExecutor::hrmp_accept_open_channel(recipient, sender)
+			}
+			(origin, Xcm::HrmpCloseChannel { sender, recipient } ) => {
+				let initiator = match origin {
+					MultiLocation::X1(Junction::Parachain { id }) => id,
+					_ => Err(XcmError::BadOrigin)?,
+				};
+				return Config::HrmpExecutor::hrmp_close_channel(initiator, sender, recipient)
+			}
+			(origin, Xcm::RelayTo { dest: MultiLocation::X1(Junction::Parachain { id }), inner }) => {
+				let msg = Xcm::RelayedFrom { superorigin: origin, inner }.into();
+				return Config::XcmSender::send_xcm(Junction::Parachain { id }.into(), msg)
+			},
 			(origin, Xcm::QueryResponse { query_id, response }) => {
 				Config::ResponseHandler::on_response(origin, query_id, response);
 				None