Add force_open_hrmp_channel Call

runtime/kusama/src/weights/runtime_parachains_hrmp.rs

@@ -156,4 +156,19 @@ impl<T: frame_system::Config> runtime_parachains::hrmp::WeightInfo for WeightInf
 			.saturating_add(T::DbWeight::get().writes(1 as u64))
 			.saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64)))
 	}
+	// Storage: Paras ParaLifecycles (r:2 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequests (r:1 w:1)
+	// Storage: Hrmp HrmpChannels (r:1 w:0)
+	// Storage: Hrmp HrmpEgressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequestCount (r:1 w:1)
+	// Storage: Hrmp HrmpOpenChannelRequestsList (r:1 w:1)
+	// Storage: Dmp DownwardMessageQueueHeads (r:2 w:2)
+	// Storage: Dmp DownwardMessageQueues (r:2 w:2)
+	// Storage: Hrmp HrmpIngressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpAcceptedChannelRequestCount (r:1 w:1)
+	fn force_open_hrmp_channel() -> Weight {
+		Weight::from_ref_time(104_771_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(13 as u64))
+			.saturating_add(T::DbWeight::get().writes(8 as u64))
+	}
 }

runtime/parachains/src/hrmp.rs

@@ -58,6 +58,7 @@ pub trait WeightInfo {
 	fn force_process_hrmp_close(c: u32) -> Weight;
 	fn hrmp_cancel_open_request(c: u32) -> Weight;
 	fn clean_open_channel_requests(c: u32) -> Weight;
+	fn force_open_hrmp_channel() -> Weight;
 }
 
 /// A weight info that is only suitable for testing.
@@ -88,6 +89,9 @@ impl WeightInfo for TestWeightInfo {
 	fn clean_open_channel_requests(_: u32) -> Weight {
 		Weight::MAX
 	}
+	fn force_open_hrmp_channel() -> Weight {
+		Weight::MAX
+	}
 }
 
 /// A description of a request to open an HRMP channel.
@@ -269,6 +273,9 @@ pub mod pallet {
 		OpenChannelAccepted(ParaId, ParaId),
 		/// HRMP channel closed. `[by_parachain, channel_id]`
 		ChannelClosed(ParaId, HrmpChannelId),
+		/// An HRMP channel was opened via Root origin.
+		/// `[sender, recipient, proposed_max_capacity, proposed_max_message_size]`
+		HrmpChannelForceOpened(ParaId, ParaId, u32, u32),
 	}
 
 	#[pallet::error]
@@ -577,6 +584,32 @@ pub mod pallet {
 			Self::deposit_event(Event::OpenChannelCanceled(origin, channel_id));
 			Ok(())
 		}
+
+		/// Open a channel from a `sender` to a `recipient` `ParaId` using the Root origin. Although
+		/// opened by Root, the `max_capacity` and `max_message_size` are still subject to the Relay
+		/// Chain's configured limits.
+		///
+		/// Expected use is when one of the `ParaId`s involved in the channel is governed by the
+		/// Relay Chain, e.g. a common good parachain.
+		#[pallet::weight(<T as Config>::WeightInfo::force_open_hrmp_channel())]
+		pub fn force_open_hrmp_channel(
+			origin: OriginFor<T>,
+			sender: ParaId,
+			recipient: ParaId,
+			max_capacity: u32,
+			max_message_size: u32,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::init_open_channel(sender, recipient, max_capacity, max_message_size)?;
+			Self::accept_open_channel(recipient, sender)?;
+			Self::deposit_event(Event::HrmpChannelForceOpened(
+				sender,
+				recipient,
+				max_capacity,
+				max_message_size,
+			));
+			Ok(())
+		}
 	}
 }
 

runtime/parachains/src/hrmp/benchmarking.rs

@@ -296,6 +296,32 @@ frame_benchmarking::benchmarks! {
 	} verify {
 		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, 0);
 	}
+
+	force_open_hrmp_channel {
+		let sender_id: ParaId = 1u32.into();
+		let recipient_id: ParaId = 2u32.into();
+
+		// make sure para is registered, and has enough balance.
+		let sender_deposit: BalanceOf<T> =
+			Configuration::<T>::config().hrmp_sender_deposit.unique_saturated_into();
+		let recipient_deposit: BalanceOf<T> =
+			Configuration::<T>::config().hrmp_recipient_deposit.unique_saturated_into();
+		register_parachain_with_balance::<T>(sender_id, sender_deposit);
+		register_parachain_with_balance::<T>(recipient_id, recipient_deposit);
+
+		let capacity = Configuration::<T>::config().hrmp_channel_max_capacity;
+		let message_size = Configuration::<T>::config().hrmp_channel_max_message_size;
+
+		// make sure this channel doesn't exist
+		let channel_id = HrmpChannelId { sender: sender_id, recipient: recipient_id };
+		assert!(HrmpOpenChannelRequests::<T>::get(&channel_id).is_none());
+		assert!(HrmpChannels::<T>::get(&channel_id).is_none());
+	}: _(frame_system::Origin::<T>::Root, sender_id, recipient_id, capacity, message_size)
+	verify {
+		assert_last_event::<T>(
+			Event::<T>::HrmpChannelForceOpened(sender_id, recipient_id, capacity, message_size).into()
+		);
+	}
 }
 
 frame_benchmarking::impl_benchmark_test_suite!(

runtime/parachains/src/hrmp/tests.rs

@@ -17,7 +17,7 @@
 use super::*;
 use crate::mock::{
 	new_test_ext, Configuration, Hrmp, MockGenesisConfig, Paras, ParasShared,
-	RuntimeEvent as MockEvent, System, Test,
+	RuntimeEvent as MockEvent, RuntimeOrigin, System, Test,
 };
 use frame_support::{assert_noop, assert_ok, traits::Currency as _};
 use primitives::v2::BlockNumber;
@@ -194,6 +194,34 @@ fn open_channel_works() {
 	});
 }
 
+#[test]
+fn force_open_channel_works() {
+	let para_a = 1.into();
+	let para_b = 3.into();
+
+	new_test_ext(GenesisConfigBuilder::default().build()).execute_with(|| {
+		// We need both A & B to be registered and live parachains.
+		register_parachain(para_a);
+		register_parachain(para_b);
+
+		run_to_block(5, Some(vec![4, 5]));
+		Hrmp::force_open_hrmp_channel(RuntimeOrigin::root(), para_a, para_b, 2, 8).unwrap();
+		Hrmp::assert_storage_consistency_exhaustive();
+		assert!(System::events().iter().any(|record| record.event ==
+			MockEvent::Hrmp(Event::HrmpChannelForceOpened(para_a, para_b, 2, 8))));
+
+		// Advance to a block 6, but without session change. That means that the channel has
+		// not been created yet.
+		run_to_block(6, None);
+		assert!(!channel_exists(para_a, para_b));
+		Hrmp::assert_storage_consistency_exhaustive();
+
+		// Now let the session change happen and thus open the channel.
+		run_to_block(8, Some(vec![8]));
+		assert!(channel_exists(para_a, para_b));
+	});
+}
+
 #[test]
 fn close_channel_works() {
 	let para_a = 5.into();

runtime/polkadot/src/lib.rs

@@ -1594,6 +1594,7 @@ mod benches {
 		[runtime_common::paras_registrar, Registrar]
 		[runtime_parachains::configuration, Configuration]
 		[runtime_parachains::disputes, ParasDisputes]
+		[runtime_parachains::hrmp, Hrmp]
 		[runtime_parachains::initializer, Initializer]
 		[runtime_parachains::paras, Paras]
 		[runtime_parachains::paras_inherent, ParaInherent]

runtime/polkadot/src/weights/runtime_parachains_hrmp.rs

@@ -154,4 +154,19 @@ impl<T: frame_system::Config> runtime_parachains::hrmp::WeightInfo for WeightInf
 			.saturating_add(T::DbWeight::get().writes(1 as u64))
 			.saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64)))
 	}
+	// Storage: Paras ParaLifecycles (r:2 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequests (r:1 w:1)
+	// Storage: Hrmp HrmpChannels (r:1 w:0)
+	// Storage: Hrmp HrmpEgressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequestCount (r:1 w:1)
+	// Storage: Hrmp HrmpOpenChannelRequestsList (r:1 w:1)
+	// Storage: Dmp DownwardMessageQueueHeads (r:2 w:2)
+	// Storage: Dmp DownwardMessageQueues (r:2 w:2)
+	// Storage: Hrmp HrmpIngressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpAcceptedChannelRequestCount (r:1 w:1)
+	fn force_open_hrmp_channel() -> Weight {
+		Weight::from_ref_time(104_771_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(13 as u64))
+			.saturating_add(T::DbWeight::get().writes(8 as u64))
+	}
 }

runtime/rococo/src/weights/runtime_parachains_hrmp.rs

@@ -160,4 +160,19 @@ impl<T: frame_system::Config> runtime_parachains::hrmp::WeightInfo for WeightInf
 			.saturating_add(T::DbWeight::get().writes(1 as u64))
 			.saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64)))
 	}
+	// Storage: Paras ParaLifecycles (r:2 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequests (r:1 w:1)
+	// Storage: Hrmp HrmpChannels (r:1 w:0)
+	// Storage: Hrmp HrmpEgressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequestCount (r:1 w:1)
+	// Storage: Hrmp HrmpOpenChannelRequestsList (r:1 w:1)
+	// Storage: Dmp DownwardMessageQueueHeads (r:2 w:2)
+	// Storage: Dmp DownwardMessageQueues (r:2 w:2)
+	// Storage: Hrmp HrmpIngressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpAcceptedChannelRequestCount (r:1 w:1)
+	fn force_open_hrmp_channel() -> Weight {
+		Weight::from_ref_time(104_771_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(13 as u64))
+			.saturating_add(T::DbWeight::get().writes(8 as u64))
+	}
 }

runtime/westend/src/weights/runtime_parachains_hrmp.rs

@@ -156,4 +156,19 @@ impl<T: frame_system::Config> runtime_parachains::hrmp::WeightInfo for WeightInf
 			.saturating_add(T::DbWeight::get().writes(1 as u64))
 			.saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64)))
 	}
+	// Storage: Paras ParaLifecycles (r:2 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequests (r:1 w:1)
+	// Storage: Hrmp HrmpChannels (r:1 w:0)
+	// Storage: Hrmp HrmpEgressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpOpenChannelRequestCount (r:1 w:1)
+	// Storage: Hrmp HrmpOpenChannelRequestsList (r:1 w:1)
+	// Storage: Dmp DownwardMessageQueueHeads (r:2 w:2)
+	// Storage: Dmp DownwardMessageQueues (r:2 w:2)
+	// Storage: Hrmp HrmpIngressChannelsIndex (r:1 w:0)
+	// Storage: Hrmp HrmpAcceptedChannelRequestCount (r:1 w:1)
+	fn force_open_hrmp_channel() -> Weight {
+		Weight::from_ref_time(104_771_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(13 as u64))
+			.saturating_add(T::DbWeight::get().writes(8 as u64))
+	}
 }