[stable2506] Backport #8787 (#8914)

Backport #8787 into `stable2506` from karolk91.

See the
[documentation](https://github.com/paritytech/polkadot-sdk/blob/master/docs/BACKPORT.md)
on how to use this bot.

<!--
  # To be used by other automation, do not modify:
  original-pr-number: #${pull_number}
-->

Co-authored-by: Karol Kokoszka <karol.k91@gmail.com>
Co-authored-by: cmd[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Branislav Kontur <bkontur@gmail.com>

Author: 4 people

Cargo.lock

@@ -112,6 +112,7 @@ members = [
 	"cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend",
 	"cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo",
 	"cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend",
+	"cumulus/parachains/integration-tests/emulated/tests/governance/westend",
 	"cumulus/parachains/integration-tests/emulated/tests/people/people-rococo",
 	"cumulus/parachains/integration-tests/emulated/tests/people/people-westend",
 	"cumulus/parachains/pallets/collective-content",

Cargo.toml

@@ -18,10 +18,12 @@ paste = { workspace = true, default-features = true }
 
 # Substrate
 frame-support = { workspace = true, default-features = true }
+frame-system = { workspace = true, default-features = true }
 pallet-asset-conversion = { workspace = true, default-features = true }
 pallet-assets = { workspace = true, default-features = true }
 pallet-balances = { workspace = true, default-features = true }
 pallet-message-queue = { workspace = true, default-features = true }
+pallet-whitelist = { workspace = true, default-features = true }
 sc-consensus-grandpa = { workspace = true, default-features = true }
 sp-authority-discovery = { workspace = true, default-features = true }
 sp-consensus-babe = { workspace = true, default-features = true }

cumulus/parachains/integration-tests/emulated/common/Cargo.toml

@@ -21,6 +21,7 @@ pub use pallet_asset_conversion;
 pub use pallet_assets;
 pub use pallet_balances;
 pub use pallet_message_queue;
+pub use pallet_whitelist;
 pub use pallet_xcm;
 
 pub use frame_support::assert_ok;
@@ -1113,3 +1114,18 @@ macro_rules! create_pool_with_native_on {
 		}
 	};
 }
+
+#[macro_export]
+macro_rules! assert_whitelisted {
+    ($chain:ident, $expected_call_hash:expr) => {
+		type RuntimeEvent = <$chain as $crate::macros::Chain>::RuntimeEvent;
+		$crate::macros::assert_expected_events!(
+			$chain,
+			vec![
+				RuntimeEvent::Whitelist($crate::macros::pallet_whitelist::Event::CallWhitelisted { call_hash }) => {
+						call_hash: *call_hash == $expected_call_hash,
+				},
+			]
+		);
+    };
+}

cumulus/parachains/integration-tests/emulated/common/src/macros.rs

@@ -21,6 +21,11 @@ use sp_core::H256;
 use xcm::{prelude::*, DoubleEncoded};
 use xcm_emulator::Chain;
 
+use crate::impls::{bx, Encode};
+use frame_support::dispatch::{DispatchResultWithPostInfo, PostDispatchInfo};
+use sp_runtime::traits::{Dispatchable, Hash};
+use xcm::{VersionedLocation, VersionedXcm};
+
 /// Helper method to build a XCM with a `Transact` instruction and paying for its execution
 pub fn xcm_transact_paid_execution(
 	call: DoubleEncoded<()>,
@@ -112,3 +117,68 @@ where
 {
 	pallet_xcm::xcm_helpers::find_xcm_sent_message_id::<<C as Chain>::Runtime>(C::events())
 }
+
+/// Wraps a runtime call in a whitelist preimage call and dispatches it
+pub fn dispatch_whitelisted_call_with_preimage<T>(
+	call: T::RuntimeCall,
+	origin: T::RuntimeOrigin,
+) -> DispatchResultWithPostInfo
+where
+	T: Chain,
+	T::Runtime: pallet_whitelist::Config,
+	T::RuntimeCall: From<pallet_whitelist::Call<T::Runtime>>
+		+ Into<<T::Runtime as pallet_whitelist::Config>::RuntimeCall>
+		+ Dispatchable<RuntimeOrigin = T::RuntimeOrigin, PostInfo = PostDispatchInfo>,
+{
+	T::execute_with(|| {
+		let whitelist_call: T::RuntimeCall =
+			pallet_whitelist::Call::<T::Runtime>::dispatch_whitelisted_call_with_preimage {
+				call: Box::new(call.into()),
+			}
+			.into();
+		whitelist_call.dispatch(origin)
+	})
+}
+
+/// Builds a `pallet_xcm::send` call to authorize an upgrade at the provided location,
+/// wrapped in an unpaid XCM `Transact` with `OriginKind::Superuser`.
+pub fn build_xcm_send_authorize_upgrade_call<T, D>(
+	location: Location,
+	code_hash: &H256,
+	fallback_max_weight: Option<Weight>,
+) -> T::RuntimeCall
+where
+	T: Chain,
+	T::Runtime: pallet_xcm::Config,
+	T::RuntimeCall: Encode + From<pallet_xcm::Call<T::Runtime>>,
+	D: Chain,
+	D::Runtime: frame_system::Config<Hash = H256>,
+	D::RuntimeCall: Encode + From<frame_system::Call<D::Runtime>>,
+{
+	let transact_call: D::RuntimeCall =
+		frame_system::Call::authorize_upgrade { code_hash: *code_hash }.into();
+
+	let call: T::RuntimeCall = pallet_xcm::Call::send {
+		dest: bx!(VersionedLocation::from(location)),
+		message: bx!(VersionedXcm::from(Xcm(vec![
+			UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+			Transact {
+				origin_kind: OriginKind::Superuser,
+				fallback_max_weight,
+				call: transact_call.encode().into(),
+			}
+		]))),
+	}
+	.into();
+	call
+}
+
+/// Encodes a runtime call and returns its H256 hash
+pub fn call_hash_of<T>(call: &T::RuntimeCall) -> H256
+where
+	T: Chain,
+	T::Runtime: frame_system::Config<Hash = H256>,
+	T::RuntimeCall: Encode,
+{
+	<T::Runtime as frame_system::Config>::Hashing::hash_of(&call)
+}

cumulus/parachains/integration-tests/emulated/common/src/xcm_helpers.rs

@@ -0,0 +1,32 @@
+[package]
+name = "governance-westend-integration-tests"
+version = "0.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+description = "Westend governance integration tests with xcm-emulator"
+publish = false
+
+[lints]
+workspace = true
+
+[dependencies]
+codec = { workspace = true, default-features = true }
+
+# Substrate
+frame-support = { workspace = true, default-features = true }
+frame-system = { workspace = true, default-features = true }
+pallet-utility = { workspace = true, default-features = true }
+pallet-whitelist = { workspace = true, default-features = true }
+sp-core = { workspace = true, default-features = true }
+sp-runtime = { workspace = true, default-features = true }
+
+pallet-xcm = { workspace = true, default-features = true }
+xcm = { workspace = true, default-features = true }
+
+emulated-integration-tests-common = { workspace = true }
+
+# Local
+collectives-westend-runtime = { workspace = true }
+westend-runtime = { workspace = true }
+westend-system-emulated-network = { workspace = true }

cumulus/parachains/integration-tests/emulated/tests/governance/westend/Cargo.toml

@@ -0,0 +1,54 @@
+// Copyright (C) Parity Technologies and the various Polkadot contributors, see Contributions.md
+// for a list of specific contributors.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::imports::*;
+
+/// CollectivesWestend dispatches `pallet_xcm::send` with `OriginKind:Xcm` to the dest with encoded
+/// whitelist call.
+#[cfg(test)]
+pub fn collectives_send_whitelist(
+	dest: Location,
+	encoded_whitelist_call: impl FnOnce() -> Vec<u8>,
+) {
+	CollectivesWestend::execute_with(|| {
+		type RuntimeEvent = <CollectivesWestend as Chain>::RuntimeEvent;
+		type RuntimeCall = <CollectivesWestend as Chain>::RuntimeCall;
+		type RuntimeOrigin = <CollectivesWestend as Chain>::RuntimeOrigin;
+		type Runtime = <CollectivesWestend as Chain>::Runtime;
+
+		let send_whitelist_call = RuntimeCall::PolkadotXcm(pallet_xcm::Call::<Runtime>::send {
+			dest: bx!(VersionedLocation::from(dest)),
+			message: bx!(VersionedXcm::from(Xcm(vec![
+				UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+				Transact {
+					origin_kind: OriginKind::Xcm,
+					fallback_max_weight: None,
+					call: encoded_whitelist_call().into(),
+				}
+			]))),
+		});
+
+		use collectives_westend_runtime::fellowship::pallet_fellowship_origins::Origin::Fellows as FellowsOrigin;
+		let fellows_origin: RuntimeOrigin = FellowsOrigin.into();
+		assert_ok!(send_whitelist_call.dispatch(fellows_origin));
+		assert_expected_events!(
+			CollectivesWestend,
+			vec![
+				RuntimeEvent::PolkadotXcm(pallet_xcm::Event::Sent { .. }) => {},
+			]
+		);
+	});
+}

cumulus/parachains/integration-tests/emulated/tests/governance/westend/src/common.rs

@@ -0,0 +1,33 @@
+// Copyright (C) Parity Technologies and the various Polkadot contributors, see Contributions.md
+// for a list of specific contributors.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#[cfg(test)]
+mod imports {
+	pub(crate) use emulated_integration_tests_common::{
+		impls::{assert_expected_events, bx, TestExt},
+		xcm_emulator::Chain,
+	};
+	pub(crate) use frame_support::assert_ok;
+	pub(crate) use sp_runtime::traits::Dispatchable;
+	pub(crate) use westend_system_emulated_network::CollectivesWestendPara as CollectivesWestend;
+	pub(crate) use xcm::{latest::prelude::*, VersionedLocation, VersionedXcm};
+}
+
+#[cfg(test)]
+mod common;
+
+#[cfg(test)]
+mod open_gov_on_relay;