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

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 sp_runtime::BuildStorage;17use sp_runtime::{BuildStorage, Storage};
18use sp_core::{Public, Pair};18use sp_core::{Public, Pair};
19use sp_std::vec;19use sp_std::vec;
20use up_common::types::AuraId;20use up_common::types::AuraId;
21use crate::{GenesisConfig, ParachainInfoConfig};21use crate::{Runtime, GenesisConfig, ParachainInfoConfig, RuntimeEvent, System};
22
23pub use sp_runtime::AccountId32 as AccountId;
24pub type Balance = u128;
2225
23pub mod xcm;26pub mod xcm;
27
28#[cfg(any(feature = "opal-runtime", feature = "quartz-runtime"))]
29/// PARA_ID for Opal/Sapphire/Quartz
30const PARA_ID: u32 = 2095;
31
32#[cfg(feature = "unique-runtime")]
33/// PARA_ID for Unique
34const PARA_ID: u32 = 2037;
2435
25fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {36fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
26	TPublic::Pair::from_string(&format!("//{}", seed), None)37	TPublic::Pair::from_string(&format!("//{}", seed), None)
27		.expect("static values are valid; qed")38		.expect("static values are valid; qed")
28		.public()39		.public()
29}40}
41
42fn last_events(n: usize) -> Vec<RuntimeEvent> {
43	System::events().into_iter().map(|e| e.event).rev().take(n).rev().collect()
44}
45
46fn new_test_ext(balances: Vec<(AccountId, Balance)>) -> sp_io::TestExternalities {
47	let mut storage = make_basic_storage();
48
49	pallet_balances::GenesisConfig::<Runtime> { balances }
50		.assimilate_storage(&mut storage)
51		.unwrap();
52
53		let mut ext = sp_io::TestExternalities::new(storage);
54		ext.execute_with(|| System::set_block_number(1));
55		ext
56}
3057
31#[cfg(feature = "collator-selection")]58#[cfg(feature = "collator-selection")]
32fn new_test_ext(para_id: u32) -> sp_io::TestExternalities {59fn make_basic_storage() -> Storage {
33	use sp_core::{sr25519};60	use sp_core::{sr25519};
34	use sp_runtime::traits::{IdentifyAccount, Verify};61	use sp_runtime::traits::{IdentifyAccount, Verify};
35	use crate::{AccountId, Signature, SessionKeys, CollatorSelectionConfig, SessionConfig};62	use crate::{AccountId, Signature, SessionKeys, CollatorSelectionConfig, SessionConfig};
66		collator_selection: CollatorSelectionConfig { invulnerables },93		collator_selection: CollatorSelectionConfig { invulnerables },
67		session: SessionConfig { keys },94		session: SessionConfig { keys },
68		parachain_info: ParachainInfoConfig {95		parachain_info: ParachainInfoConfig {
69			parachain_id: para_id.into(),96			parachain_id: PARA_ID.into(),
70		},97		},
71		..GenesisConfig::default()98		..GenesisConfig::default()
72	};99	};
75}102}
76103
77#[cfg(not(feature = "collator-selection"))]104#[cfg(not(feature = "collator-selection"))]
78fn new_test_ext(para_id: u32) -> sp_io::TestExternalities {105fn make_basic_storage() -> Storage {
79	use crate::AuraConfig;106	use crate::AuraConfig;
80107
81	let cfg = GenesisConfig {108	let cfg = GenesisConfig {
86			],113			],
87		},114		},
88		parachain_info: ParachainInfoConfig {115		parachain_info: ParachainInfoConfig {
89			parachain_id: para_id.into(),116			parachain_id: PARA_ID.into(),
90		},117		},
91		..GenesisConfig::default()118		..GenesisConfig::default()
92	};119	};

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

307307
308impl-trait-for-tuples = { workspace = true }308impl-trait-for-tuples = { workspace = true }
309
310[dev-dependencies]
311logtest = { workspace = true }
312309
313[build-dependencies]310[build-dependencies]
314substrate-wasm-builder = { workspace = true }311substrate-wasm-builder = { workspace = true }

4141
42pub mod xcm_barrier;42pub mod xcm_barrier;
43
44#[cfg(test)]
45mod tests;
4643
47pub use runtime_common::*;44pub use runtime_common::*;
4845

300300
301impl-trait-for-tuples = { workspace = true }301impl-trait-for-tuples = { workspace = true }
302
303[dev-dependencies]
304logtest = { workspace = true }
305302
306[build-dependencies]303[build-dependencies]
307substrate-wasm-builder = { workspace = true }304substrate-wasm-builder = { workspace = true }

4141
42pub mod xcm_barrier;42pub mod xcm_barrier;
43
44#[cfg(test)]
45mod tests;
4643
47pub use runtime_common::*;44pub use runtime_common::*;
4845

298298
299impl-trait-for-tuples = { workspace = true }299impl-trait-for-tuples = { workspace = true }
300
301[dev-dependencies]
302logtest = { workspace = true }
303300
304[build-dependencies]301[build-dependencies]
305substrate-wasm-builder = { workspace = true }302substrate-wasm-builder = { workspace = true }

4141
42pub mod xcm_barrier;42pub mod xcm_barrier;
43
44#[cfg(test)]
45mod tests;
4643
47pub use runtime_common::*;44pub use runtime_common::*;
4845