git.delta.rocks / unique-network / refs/commits / 4e84fdd5539f

--- a/runtime/common/tests/mod.rs
+++ b/runtime/common/tests/mod.rs
@@ -14,22 +14,49 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-use sp_runtime::BuildStorage;
+use sp_runtime::{BuildStorage, Storage};
 use sp_core::{Public, Pair};
 use sp_std::vec;
 use up_common::types::AuraId;
-use crate::{GenesisConfig, ParachainInfoConfig};
+use crate::{Runtime, GenesisConfig, ParachainInfoConfig, RuntimeEvent, System};
+
+pub use sp_runtime::AccountId32 as AccountId;
+pub type Balance = u128;
 
 pub mod xcm;
 
+#[cfg(any(feature = "opal-runtime", feature = "quartz-runtime"))]
+/// PARA_ID for Opal/Sapphire/Quartz
+const PARA_ID: u32 = 2095;
+
+#[cfg(feature = "unique-runtime")]
+/// PARA_ID for Unique
+const PARA_ID: u32 = 2037;
+
 fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
 	TPublic::Pair::from_string(&format!("//{}", seed), None)
 		.expect("static values are valid; qed")
 		.public()
 }
 
+fn last_events(n: usize) -> Vec<RuntimeEvent> {
+	System::events().into_iter().map(|e| e.event).rev().take(n).rev().collect()
+}
+
+fn new_test_ext(balances: Vec<(AccountId, Balance)>) -> sp_io::TestExternalities {
+	let mut storage = make_basic_storage();
+
+	pallet_balances::GenesisConfig::<Runtime> { balances }
+		.assimilate_storage(&mut storage)
+		.unwrap();
+
+		let mut ext = sp_io::TestExternalities::new(storage);
+		ext.execute_with(|| System::set_block_number(1));
+		ext
+}
+
 #[cfg(feature = "collator-selection")]
-fn new_test_ext(para_id: u32) -> sp_io::TestExternalities {
+fn make_basic_storage() -> Storage {
 	use sp_core::{sr25519};
 	use sp_runtime::traits::{IdentifyAccount, Verify};
 	use crate::{AccountId, Signature, SessionKeys, CollatorSelectionConfig, SessionConfig};
@@ -66,7 +93,7 @@
 		collator_selection: CollatorSelectionConfig { invulnerables },
 		session: SessionConfig { keys },
 		parachain_info: ParachainInfoConfig {
-			parachain_id: para_id.into(),
+			parachain_id: PARA_ID.into(),
 		},
 		..GenesisConfig::default()
 	};
@@ -75,7 +102,7 @@
 }
 
 #[cfg(not(feature = "collator-selection"))]
-fn new_test_ext(para_id: u32) -> sp_io::TestExternalities {
+fn make_basic_storage() -> Storage {
 	use crate::AuraConfig;
 
 	let cfg = GenesisConfig {
@@ -86,7 +113,7 @@
 			],
 		},
 		parachain_info: ParachainInfoConfig {
-			parachain_id: para_id.into(),
+			parachain_id: PARA_ID.into(),
 		},
 		..GenesisConfig::default()
 	};

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17use xcm_executor::traits::ShouldExecute;
18use xcm::latest::prelude::*;17use xcm::{
18	VersionedXcm,
19	latest::{prelude::*, Error}
20};
19use logtest::Logger;21use codec::Encode;
20use crate::RuntimeCall;22use crate::{Runtime, RuntimeCall, RuntimeOrigin, RuntimeEvent, PolkadotXcm};
21use super::new_test_ext;23use super::{new_test_ext, last_events, AccountId};
22use frame_support::pallet_prelude::Weight;24use frame_support::{
2325	pallet_prelude::Weight,
24fn catch_xcm_barrier_log(logger: &mut Logger, expected_msg: &str) -> Result<(), String> {26};
25	for record in logger {
26		if record.target() == "xcm::barrier" && record.args() == expected_msg {
27			return Ok(());
28		}
29	}
30
31	Err(format!(
32		"the expected XCM barrier log `{}` is not found",
33		expected_msg
34	))
35}
36
37/// WARNING: Uses log capturing
38/// See https://docs.rs/logtest/latest/logtest/index.html#constraints
39pub fn barrier_denies_transact<B: ShouldExecute>(logger: &mut Logger) {
40	let location = MultiLocation {
41		parents: 0,
42		interior: Junctions::Here,
43	};
44
45	// We will never decode this "call",
46	// so it is irrelevant what we are passing to the `transact` cmd.
47	let fake_encoded_call = vec![0u8];
48
49	let transact_inst: Instruction<RuntimeCall> = Transact {
50		origin_kind: OriginKind::Superuser,
51		require_weight_at_most: Weight::default(),
52		call: fake_encoded_call.into(),
53	};
54
55	let mut xcm_program = vec![transact_inst];
56
57	let max_weight = Weight::from_parts(100_000, 100_000);
58	let mut weight_credit = Weight::from_parts(100_000_000, 100_000_000);
59
60	let result = B::should_execute(&location, &mut xcm_program, max_weight, &mut weight_credit);
61
62	assert!(
63		result.is_err(),
64		"the barrier should disallow the XCM transact cmd"
65	);
66
67	catch_xcm_barrier_log(logger, "transact XCM rejected").unwrap();
68}
69
70fn xcm_execute<B: ShouldExecute>(
71	self_para_id: u32,
72	location: &MultiLocation,
73	xcm: &mut [Instruction<RuntimeCall>],
74) -> Result<(), ()> {
75	new_test_ext(self_para_id).execute_with(|| {
76		let max_weight = Weight::from_parts(100_000, 100_000);
77		let mut weight_credit = Weight::from_parts(100_000_000, 100_000_000);
78
79		B::should_execute(&location, xcm, max_weight, &mut weight_credit)
80	})
81}
82
83fn make_multiassets(location: &MultiLocation) -> MultiAssets {
84	let id = AssetId::Concrete(location.clone());
85	let fun = Fungibility::Fungible(42);
86	let multiasset = MultiAsset { id, fun };
87
88	multiasset.into()
89}
9027
91fn make_transfer_reserve_asset(location: &MultiLocation) -> Xcm<RuntimeCall> {28const ALICE: AccountId = AccountId::new([0u8; 32]);
92	let assets = make_multiassets(location);
93	let inst = TransferReserveAsset {
94		assets,
95		dest: location.clone(),
96		xcm: Xcm(vec![]),
97	};
98
99	Xcm::<RuntimeCall>(vec![inst])
100}
101
102fn make_deposit_reserve_asset(location: &MultiLocation) -> Xcm<RuntimeCall> {29const BOB: AccountId = AccountId::new([1u8; 32]);
103	let assets = make_multiassets(location);30
104	let inst = DepositReserveAsset {
105		assets: assets.into(),
106		dest: location.clone(),
107		xcm: Xcm(vec![]),
108	};
109
110	Xcm::<RuntimeCall>(vec![inst])
111}
112
113fn expect_transfer_location_denied<B: ShouldExecute>(
114	logger: &mut Logger,31const INITIAL_BALANCE: u128 = 1000000000000000000_0000; // 1000 UNQ 
115	self_para_id: u32,32
116	location: &MultiLocation,33#[test]
117	xcm: &mut [Instruction<RuntimeCall>],
118) -> Result<(), String> {
119	let result = xcm_execute::<B>(self_para_id, location, xcm);
120
121	if result.is_ok() {
122		return Err("the barrier should deny the unknown location".into());
123	}
124
125	catch_xcm_barrier_log(logger, "Unexpected deposit or transfer location")
126}
127
128/// WARNING: Uses log capturing
129/// See https://docs.rs/logtest/latest/logtest/index.html#constraints
130pub fn barrier_denies_transfer_from_unknown_location<B>(34pub fn xcm_transact_is_forbidden() {
131	logger: &mut Logger,
132	self_para_id: u32,
133) -> Result<(), String>35	new_test_ext(vec![(ALICE, INITIAL_BALANCE)]).execute_with(|| {
134where36		PolkadotXcm::execute(
135	B: ShouldExecute,37			RuntimeOrigin::signed(ALICE),
136{38			Box::new(VersionedXcm::from(Xcm(vec![
137	const UNKNOWN_PARACHAIN_ID: u32 = 4057;39				Transact {
13840					origin_kind: OriginKind::Native,
139	let unknown_location = MultiLocation {
140		parents: 1,41					require_weight_at_most: Weight::from_parts(1000, 1000),
141		interior: X1(Parachain(UNKNOWN_PARACHAIN_ID)),42					call: RuntimeCall::Balances(
142	};43						pallet_balances::Call::<Runtime>::transfer {
14344							dest: BOB.into(),
45							value: INITIAL_BALANCE / 2,
46						}
47					).encode().into(),
48				}
49			]))),
50			Weight::from_parts(1001000, 2000),
144	let mut transfer_reserve_asset = make_transfer_reserve_asset(&unknown_location);51		).expect("XCM execute must succeed, the error should be in the `PolkadotXcm::Attempted` event");
52
145	let mut deposit_reserve_asset = make_deposit_reserve_asset(&unknown_location);53		let xcm_event = &last_events(1)[0];
14654		match xcm_event {
147	expect_transfer_location_denied::<B>(55			RuntimeEvent::PolkadotXcm(
148		logger,
149		self_para_id,
150		&unknown_location,
151		&mut transfer_reserve_asset.0,
152	)?;
153
154	expect_transfer_location_denied::<B>(56				pallet_xcm::Event::<Runtime>::Attempted(
155		logger,
156		self_para_id,
157		&unknown_location,57					Outcome::Incomplete(_weight, Error::NoPermission)
158		&mut deposit_reserve_asset.0,
159	)?;58				)
16059			) => { /* Pass */ },
161	Ok(())60			_ => panic!(
162}61				"Expected PolkadotXcm.Attempted(Incomplete(_weight, NoPermission)),\
62				found: {xcm_event:#?}"
63			)
64		}
65	});
66}
16367

--- a/runtime/opal/Cargo.toml
+++ b/runtime/opal/Cargo.toml
@@ -307,8 +307,5 @@
 
 impl-trait-for-tuples = { workspace = true }
 
-[dev-dependencies]
-logtest = { workspace = true }
-
 [build-dependencies]
 substrate-wasm-builder = { workspace = true }

--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/src/lib.rs
@@ -41,9 +41,6 @@
 
 pub mod xcm_barrier;
 
-#[cfg(test)]
-mod tests;
-
 pub use runtime_common::*;
 
 pub const RUNTIME_NAME: &str = "opal";

--- a/runtime/quartz/Cargo.toml
+++ b/runtime/quartz/Cargo.toml
@@ -300,8 +300,5 @@
 
 impl-trait-for-tuples = { workspace = true }
 
-[dev-dependencies]
-logtest = { workspace = true }
-
 [build-dependencies]
 substrate-wasm-builder = { workspace = true }

--- a/runtime/quartz/src/lib.rs
+++ b/runtime/quartz/src/lib.rs
@@ -41,9 +41,6 @@
 
 pub mod xcm_barrier;
 
-#[cfg(test)]
-mod tests;
-
 pub use runtime_common::*;
 
 #[cfg(feature = "become-sapphire")]

--- a/runtime/unique/Cargo.toml
+++ b/runtime/unique/Cargo.toml
@@ -298,8 +298,5 @@
 
 impl-trait-for-tuples = { workspace = true }
 
-[dev-dependencies]
-logtest = { workspace = true }
-
 [build-dependencies]
 substrate-wasm-builder = { workspace = true }

--- a/runtime/unique/src/lib.rs
+++ b/runtime/unique/src/lib.rs
@@ -41,9 +41,6 @@
 
 pub mod xcm_barrier;
 
-#[cfg(test)]
-mod tests;
-
 pub use runtime_common::*;
 
 pub const RUNTIME_NAME: &str = "unique";