git.delta.rocks / unique-network / refs/commits / 25b276d53c18

--- a/pallets/foreing-assets/src/lib.rs
+++ b/pallets/foreing-assets/src/lib.rs
@@ -54,7 +54,7 @@
 
 // NOTE:v1::MultiLocation is used in storages, we would need to do migration if upgrade the
 // MultiLocation in the future.
-use xcm::opaque::latest::{prelude::XcmError, MultiAsset};
+use xcm::opaque::latest::prelude::XcmError;
 use xcm::{v1::MultiLocation, VersionedMultiLocation};
 use xcm_executor::{traits::WeightTrader, Assets};
 
@@ -445,8 +445,6 @@
 	}
 }
 
-use sp_runtime::SaturatedConversion;
-use sp_runtime::traits::Saturating;
 pub use frame_support::{
 	traits::{
 		fungibles::{Balanced, CreditOf},
@@ -455,8 +453,6 @@
 	},
 	weights::{WeightToFeePolynomial, WeightToFee},
 };
-
-use xcm::latest::{Fungibility::Fungible as XcmFungible};
 
 pub struct FreeForAll<
 	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,

--- a/runtime/common/tests/mod.rs
+++ b/runtime/common/tests/mod.rs
@@ -29,20 +29,18 @@
 }
 
 fn new_test_ext(para_id: u32) -> sp_io::TestExternalities {
-    let cfg = GenesisConfig {
-        aura: AuraConfig {
-            authorities: vec![
-                get_from_seed::<AuraId>("Alice"),
-                get_from_seed::<AuraId>("Bob"),
-            ],
-        },
-        parachain_info: ParachainInfoConfig {
-            parachain_id: para_id.into(),
-        },
-        ..GenesisConfig::default()
-    };
+	let cfg = GenesisConfig {
+		aura: AuraConfig {
+			authorities: vec![
+				get_from_seed::<AuraId>("Alice"),
+				get_from_seed::<AuraId>("Bob"),
+			],
+		},
+		parachain_info: ParachainInfoConfig {
+			parachain_id: para_id.into(),
+		},
+		..GenesisConfig::default()
+	};
 
-	cfg.build_storage()
-        .unwrap()
-		.into()
+	cfg.build_storage().unwrap().into()
 }

--- a/runtime/common/tests/xcm.rs
+++ b/runtime/common/tests/xcm.rs
@@ -20,154 +20,143 @@
 use crate::Call;
 use super::new_test_ext;
 
-fn catch_xcm_barrier_log(
-    logger: &mut Logger,
-    expected_msg: &str
-) -> Result<(), String> {
-    for record in logger {
-        if record.target() == "xcm::barrier"
-        && record.args() == expected_msg {
-            return Ok(());
-        }
-    }
+fn catch_xcm_barrier_log(logger: &mut Logger, expected_msg: &str) -> Result<(), String> {
+	for record in logger {
+		if record.target() == "xcm::barrier" && record.args() == expected_msg {
+			return Ok(());
+		}
+	}
 
-    Err(format!("the expected XCM barrier log `{}` is not found", expected_msg))
+	Err(format!(
+		"the expected XCM barrier log `{}` is not found",
+		expected_msg
+	))
 }
 
 /// WARNING: Uses log capturing
 /// See https://docs.rs/logtest/latest/logtest/index.html#constraints
 pub fn barrier_denies_transact<B: ShouldExecute>(logger: &mut Logger) {
-    let location = MultiLocation {
-        parents: 0,
-        interior: Junctions::Here,
-    };
+	let location = MultiLocation {
+		parents: 0,
+		interior: Junctions::Here,
+	};
 
-    // We will never decode this "call",
-    // so it is irrelevant what we are passing to the `transact` cmd.
-    let fake_encoded_call = vec![0u8];
+	// We will never decode this "call",
+	// so it is irrelevant what we are passing to the `transact` cmd.
+	let fake_encoded_call = vec![0u8];
 
-    let transact_inst = Transact {
-        origin_type: OriginKind::Superuser,
-        require_weight_at_most: 0,
-        call: fake_encoded_call.into(),
-    };
+	let transact_inst = Transact {
+		origin_type: OriginKind::Superuser,
+		require_weight_at_most: 0,
+		call: fake_encoded_call.into(),
+	};
 
-    let mut xcm_program = Xcm::<Call>(vec![transact_inst]);
+	let mut xcm_program = Xcm::<Call>(vec![transact_inst]);
 
-    let max_weight = 100_000;
-    let mut weight_credit = 100_000_000;
+	let max_weight = 100_000;
+	let mut weight_credit = 100_000_000;
 
-    let result = B::should_execute(
-        &location,
-        &mut xcm_program,
-        max_weight,
-        &mut weight_credit
-    );
+	let result = B::should_execute(&location, &mut xcm_program, max_weight, &mut weight_credit);
 
-    assert!(result.is_err(), "the barrier should disallow the XCM transact cmd");
+	assert!(
+		result.is_err(),
+		"the barrier should disallow the XCM transact cmd"
+	);
 
-    catch_xcm_barrier_log(logger, "transact XCM rejected").unwrap();
+	catch_xcm_barrier_log(logger, "transact XCM rejected").unwrap();
 }
 
 fn xcm_execute<B: ShouldExecute>(
-    self_para_id: u32,
-    location: &MultiLocation,
-    xcm: &mut Xcm<Call>
+	self_para_id: u32,
+	location: &MultiLocation,
+	xcm: &mut Xcm<Call>,
 ) -> Result<(), ()> {
-    new_test_ext(self_para_id).execute_with(|| {
-        let max_weight = 100_000;
-        let mut weight_credit = 100_000_000;
+	new_test_ext(self_para_id).execute_with(|| {
+		let max_weight = 100_000;
+		let mut weight_credit = 100_000_000;
 
-        B::should_execute(
-            &location,
-            xcm,
-            max_weight,
-            &mut weight_credit
-        )
-    })
+		B::should_execute(&location, xcm, max_weight, &mut weight_credit)
+	})
 }
 
 fn make_multiassets(location: &MultiLocation) -> MultiAssets {
-    let id = AssetId::Concrete(location.clone());
-    let fun = Fungibility::Fungible(42);
-    let multiasset = MultiAsset {
-        id,
-        fun,
-    };
+	let id = AssetId::Concrete(location.clone());
+	let fun = Fungibility::Fungible(42);
+	let multiasset = MultiAsset { id, fun };
 
-    multiasset.into()
+	multiasset.into()
 }
 
 fn make_transfer_reserve_asset(location: &MultiLocation) -> Xcm<Call> {
-    let assets = make_multiassets(location);
-    let inst = TransferReserveAsset {
-        assets,
-        dest: location.clone(),
-        xcm: Xcm(vec![]),
-    };
+	let assets = make_multiassets(location);
+	let inst = TransferReserveAsset {
+		assets,
+		dest: location.clone(),
+		xcm: Xcm(vec![]),
+	};
 
-    Xcm::<Call>(vec![inst])
+	Xcm::<Call>(vec![inst])
 }
 
 fn make_deposit_reserve_asset(location: &MultiLocation) -> Xcm<Call> {
-    let assets = make_multiassets(location);
-    let inst = DepositReserveAsset {
-        assets: assets.into(),
-        max_assets: 42,
-        dest: location.clone(),
-        xcm: Xcm(vec![]),
-    };
+	let assets = make_multiassets(location);
+	let inst = DepositReserveAsset {
+		assets: assets.into(),
+		max_assets: 42,
+		dest: location.clone(),
+		xcm: Xcm(vec![]),
+	};
 
-    Xcm::<Call>(vec![inst])
+	Xcm::<Call>(vec![inst])
 }
 
 fn expect_transfer_location_denied<B: ShouldExecute>(
-    logger: &mut Logger,
-    self_para_id: u32,
-    location: &MultiLocation,
-    xcm: &mut Xcm<Call>
+	logger: &mut Logger,
+	self_para_id: u32,
+	location: &MultiLocation,
+	xcm: &mut Xcm<Call>,
 ) -> Result<(), String> {
-    let result = xcm_execute::<B>(self_para_id, location, xcm);
+	let result = xcm_execute::<B>(self_para_id, location, xcm);
 
-    if result.is_ok() {
-        return Err("the barrier should deny the unknown location".into());
-    }
+	if result.is_ok() {
+		return Err("the barrier should deny the unknown location".into());
+	}
 
-    catch_xcm_barrier_log(logger, "Unexpected deposit or transfer location")
+	catch_xcm_barrier_log(logger, "Unexpected deposit or transfer location")
 }
 
 /// WARNING: Uses log capturing
 /// See https://docs.rs/logtest/latest/logtest/index.html#constraints
 pub fn barrier_denies_transfer_from_unknown_location<B>(
-    logger: &mut Logger,
-    self_para_id: u32,
+	logger: &mut Logger,
+	self_para_id: u32,
 ) -> Result<(), String>
 where
-    B: ShouldExecute
+	B: ShouldExecute,
 {
-    const UNKNOWN_PARACHAIN_ID: u32 = 4057;
+	const UNKNOWN_PARACHAIN_ID: u32 = 4057;
 
-    let unknown_location = MultiLocation {
-        parents: 1,
-        interior: X1(Parachain(UNKNOWN_PARACHAIN_ID)),
-    };
+	let unknown_location = MultiLocation {
+		parents: 1,
+		interior: X1(Parachain(UNKNOWN_PARACHAIN_ID)),
+	};
 
-    let mut transfer_reserve_asset = make_transfer_reserve_asset(&unknown_location);
-    let mut deposit_reserve_asset = make_deposit_reserve_asset(&unknown_location);
+	let mut transfer_reserve_asset = make_transfer_reserve_asset(&unknown_location);
+	let mut deposit_reserve_asset = make_deposit_reserve_asset(&unknown_location);
 
-    expect_transfer_location_denied::<B>(
-        logger,
-        self_para_id,
-        &unknown_location,
-        &mut transfer_reserve_asset
-    )?;
+	expect_transfer_location_denied::<B>(
+		logger,
+		self_para_id,
+		&unknown_location,
+		&mut transfer_reserve_asset,
+	)?;
 
-    expect_transfer_location_denied::<B>(
-        logger,
-        self_para_id,
-        &unknown_location,
-        &mut deposit_reserve_asset
-    )?;
+	expect_transfer_location_denied::<B>(
+		logger,
+		self_para_id,
+		&unknown_location,
+		&mut deposit_reserve_asset,
+	)?;
 
-    Ok(())
+	Ok(())
 }

--- a/runtime/opal/src/tests/logcapture.rs
+++ b/runtime/opal/src/tests/logcapture.rs
@@ -19,7 +19,7 @@
 
 #[test]
 fn opal_log_capture_tests() {
-    let mut logger = Logger::start();
-    
-    opal_xcm_tests(&mut logger);
+	let mut logger = Logger::start();
+
+	opal_xcm_tests(&mut logger);
 }

--- a/runtime/opal/src/tests/mod.rs
+++ b/runtime/opal/src/tests/mod.rs
@@ -14,5 +14,5 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+mod logcapture;
 mod xcm;
-mod logcapture;

--- a/runtime/opal/src/tests/xcm.rs
+++ b/runtime/opal/src/tests/xcm.rs
@@ -15,18 +15,13 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 use logtest::Logger;
-use crate::{
-    runtime_common::tests::xcm::*,
-    xcm_config::Barrier,
-};
+use crate::{runtime_common::tests::xcm::*, xcm_config::Barrier};
 
 const OPAL_PARA_ID: u32 = 2095; // Same as Quartz
 
 pub fn opal_xcm_tests(logger: &mut Logger) {
-    barrier_denies_transact::<Barrier>(logger);
+	barrier_denies_transact::<Barrier>(logger);
 
-    barrier_denies_transfer_from_unknown_location::<Barrier>(
-        logger,
-        OPAL_PARA_ID,
-    ).expect_err("opal runtime allows any location");
+	barrier_denies_transfer_from_unknown_location::<Barrier>(logger, OPAL_PARA_ID)
+		.expect_err("opal runtime allows any location");
 }

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 cumulus_pallet_xcm;
18use frame_support::{17use frame_support::{
19	{match_types, parameter_types, weights::Weight},18	{match_types, parameter_types, weights::Weight},
20	pallet_prelude::Get,19	pallet_prelude::Get,
21	traits::{Contains, Everything, fungibles},20	traits::{Contains, Everything},
22};21};
23use frame_system::EnsureRoot;
24use orml_traits::{location::AbsoluteReserveProvider, parameter_type_with_key};22use orml_traits::{location::AbsoluteReserveProvider, parameter_type_with_key};
25use pallet_xcm::XcmPassthrough;
26use polkadot_parachain::primitives::Sibling;
27use sp_runtime::traits::{AccountIdConversion, CheckedConversion, Convert, Zero};23use sp_runtime::traits::{AccountIdConversion, Convert};
28use sp_std::{borrow::Borrow, marker::PhantomData, vec, vec::Vec};24use sp_std::{vec, vec::Vec};
29use xcm::{25use xcm::{
30	latest::{MultiAsset, Xcm},26	latest::Xcm,
31	prelude::{Concrete, Fungible as XcmFungible},
32	v1::{BodyId, Junction::*, Junctions::*, MultiLocation, NetworkId},27	v1::{BodyId, Junction::*, Junctions::*, MultiLocation, NetworkId},
33};28};
34use xcm_builder::{29use xcm_builder::{
35	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, EnsureXcmOrigin,30	AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, FixedWeightBounds, LocationInverter,
36	FixedWeightBounds, FungiblesAdapter, LocationInverter, ParentAsSuperuser, ParentIsPreset,
37	RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
38	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,31	TakeWeightCredit,
39	ConvertedConcreteAssetId,
40};32};
41use xcm_executor::{33use xcm_executor::{XcmExecutor, traits::ShouldExecute};
42	{Config, XcmExecutor},
43	traits::{Convert as ConvertXcm, FilterAssetLocation, JustTry, MatchesFungible, ShouldExecute},
44};
4534
46use up_common::{35use up_common::types::{AccountId, Balance};
47	constants::{MAXIMUM_BLOCK_WEIGHT, UNIQUE},
48	types::{AccountId, Balance},
49};
50
51use crate::{
52	Balances, Call, DmpQueue, Event, ForeingAssets, Origin, ParachainInfo, ParachainSystem,
53	PolkadotXcm, Runtime, XcmpQueue,
54};
55use crate::runtime_common::config::substrate::{TreasuryModuleId, MaxLocks, MaxReserves};36use crate::{
56use crate::runtime_common::config::pallets::TreasuryAccountId;37	Call, Event, ParachainInfo, Runtime,
57use crate::runtime_common::config::xcm::*;38	runtime_common::config::{
58use crate::*;39		substrate::{TreasuryModuleId, MaxLocks, MaxReserves},
40		pallets::TreasuryAccountId,
41		xcm::*,
42	},
43};
5944
60use pallet_foreing_assets::{45use pallet_foreing_assets::{
61	AssetIds, AssetIdMapping, XcmForeignAssetIdMapping, CurrencyId, NativeCurrency, FreeForAll,46	AssetIds, AssetIdMapping, XcmForeignAssetIdMapping, CurrencyId, NativeCurrency,
62	TryAsForeing, ForeignAssetId,
63};47};
6448
65// Signed version of balance49// Signed version of balance
66pub type Amount = i128;50pub type Amount = i128;
67
68parameter_types! {
69	pub const RelayLocation: MultiLocation = MultiLocation::parent();
70	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;
71	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();
72	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
73	pub SelfLocation: MultiLocation = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
74}
75
76/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,
77/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can
78/// biases the kind of local `Origin` it will become.
79pub type XcmOriginToTransactDispatchOrigin = (
80	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location
81	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for
82	// foreign chains who want to have a local sovereign account on this chain which they control.
83	SovereignSignedViaLocation<LocationToAccountId, Origin>,
84	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when
85	// recognised.
86	RelayChainAsNative<RelayOrigin, Origin>,
87	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when
88	// recognised.
89	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,
90	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a
91	// transaction from the Root origin.
92	ParentAsSuperuser<Origin>,
93	// Native signed account converter; this just converts an `AccountId32` origin into a normal
94	// `Origin::Signed` origin of the same 32-byte value.
95	SignedAccountId32AsNative<RelayNetwork, Origin>,
96	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.
97	XcmPassthrough<Origin>,
98);
99
100parameter_types! {
101	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.
102	pub UnitWeightCost: Weight = 1_000_000;
103	// 1200 UNIQUEs buy 1 second of weight.
104	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);
105	pub const MaxInstructions: u32 = 100;
106	pub const MaxAuthorities: u32 = 100_000;
107}
10851
109match_types! {52match_types! {
110	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {53	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {
123	fn should_execute<Call>(66	fn should_execute<Call>(
124		_origin: &MultiLocation,67		_origin: &MultiLocation,
125		_message: &mut Xcm<Call>,68		_message: &mut Xcm<Call>,
126		max_weight: Weight,69		_max_weight: Weight,
127		weight_credit: &mut Weight,70		_weight_credit: &mut Weight,
128	) -> Result<(), ()> {71	) -> Result<(), ()> {
129		Ok(())72		Ok(())
130	}73	}
138		AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,81		AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,
139		// ^^^ Parent & its unit plurality gets free execution82		// ^^^ Parent & its unit plurality gets free execution
140		AllowAllDebug,83		AllowAllDebug,
141	)84	),
142>;85>;
14386
144pub struct AllAsset;
145impl FilterAssetLocation for AllAsset {
146	fn filter_asset_location(asset: &MultiAsset, origin: &MultiLocation) -> bool {
147		true
148	}
149}
150
151pub struct CurrencyIdConvert;
152impl Convert<AssetIds, Option<MultiLocation>> for CurrencyIdConvert {
153	fn convert(id: AssetIds) -> Option<MultiLocation> {
154		match id {
155			AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
156				1,
157				X1(Parachain(ParachainInfo::get().into())),
158			)),
159			AssetIds::NativeAssetId(NativeCurrency::Parent) => Some(MultiLocation::parent()),
160			AssetIds::ForeignAssetId(foreign_asset_id) => {
161				XcmForeignAssetIdMapping::<Runtime>::get_multi_location(foreign_asset_id)
162			}
163		}
164	}
165}
166impl Convert<MultiLocation, Option<CurrencyId>> for CurrencyIdConvert {87impl Convert<MultiLocation, Option<CurrencyId>> for CurrencyIdConvert {
167	fn convert(location: MultiLocation) -> Option<CurrencyId> {88	fn convert(location: MultiLocation) -> Option<CurrencyId> {
168		if location == MultiLocation::here()89		if location == MultiLocation::here()
185	}106	}
186}107}
187108
109impl orml_tokens::Config for Runtime {
110	type Event = Event;
111	type Balance = Balance;
112	type Amount = Amount;
113	type CurrencyId = CurrencyId;
188pub fn get_all_module_accounts() -> Vec<AccountId> {114	type WeightInfo = ();
115	type ExistentialDeposits = ExistentialDeposits;
116	type OnDust = orml_tokens::TransferDust<Runtime, TreasuryAccountId>;
117	type MaxLocks = MaxLocks;
118	type MaxReserves = MaxReserves;
119	// TODO: Add all module accounts
120	type DustRemovalWhitelist = DustRemovalWhitelist;
121	/// The id type for named reserves.
122	type ReserveIdentifier = ();
123	type OnNewTokenAccount = ();
124	type OnKilledTokenAccount = ();
125}
126
127impl orml_xtokens::Config for Runtime {
128	type Event = Event;
129	type Balance = Balance;
130	type CurrencyId = CurrencyId;
131	type CurrencyIdConvert = CurrencyIdConvert;
132	type AccountIdToMultiLocation = AccountIdToMultiLocation;
133	type SelfLocation = SelfLocation;
134	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
135	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
136	type BaseXcmWeight = BaseXcmWeight;
137	type LocationInverter = LocationInverter<Ancestry>;
138	type MaxAssetsForTransfer = MaxAssetsForTransfer;
139	type MinXcmFee = ParachainMinFee;
140	type MultiLocationsFilter = Everything;
141	type ReserveProvider = AbsoluteReserveProvider;
142}
143
189	vec![TreasuryModuleId::get().into_account_truncating()]144parameter_type_with_key! {
190}145	pub ExistentialDeposits: |currency_id: CurrencyId| -> Balance {
146		match currency_id {
147			CurrencyId::NativeAssetId(symbol) => match symbol {
148				NativeCurrency::Here => 0,
149				NativeCurrency::Parent=> 0,
150			},
151			_ => 100_000
152		}
153	};
154}
191155
192pub struct DustRemovalWhitelist;156pub struct DustRemovalWhitelist;
193impl Contains<AccountId> for DustRemovalWhitelist {157impl Contains<AccountId> for DustRemovalWhitelist {
196	}160	}
197}161}
198162
199parameter_type_with_key! {
200	pub ExistentialDeposits: |currency_id: CurrencyId| -> Balance {163pub struct CurrencyIdConvert;
201		match currency_id {
202			CurrencyId::NativeAssetId(symbol) => match symbol {
203				NativeCurrency::Here => 0,
204				NativeCurrency::Parent=> 0,
205			},
206			_ => 100_000
207		}
208	};
209}
210
211impl orml_tokens::Config for Runtime {164impl Convert<AssetIds, Option<MultiLocation>> for CurrencyIdConvert {
212	type Event = Event;165	fn convert(id: AssetIds) -> Option<MultiLocation> {
213	type Balance = Balance;166		match id {
214	type Amount = Amount;167			AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
215	type CurrencyId = CurrencyId;168				1,
216	type WeightInfo = ();
217	type ExistentialDeposits = ExistentialDeposits;
218	type OnDust = orml_tokens::TransferDust<Runtime, TreasuryAccountId>;169				X1(Parachain(ParachainInfo::get().into())),
219	type MaxLocks = MaxLocks;170			)),
220	type MaxReserves = MaxReserves;
221	// TODO: Add all module accounts
222	type DustRemovalWhitelist = DustRemovalWhitelist;
223	/// The id type for named reserves.
224	type ReserveIdentifier = ();171			AssetIds::NativeAssetId(NativeCurrency::Parent) => Some(MultiLocation::parent()),
225	type OnNewTokenAccount = ();172			AssetIds::ForeignAssetId(foreign_asset_id) => {
226	type OnKilledTokenAccount = ();173				XcmForeignAssetIdMapping::<Runtime>::get_multi_location(foreign_asset_id)
174			}
175		}
176	}
227}177}
228178
229parameter_types! {179parameter_types! {
230	pub const BaseXcmWeight: Weight = 100_000_000; // TODO: recheck this180	pub const BaseXcmWeight: Weight = 100_000_000; // TODO: recheck this
231	pub const MaxAssetsForTransfer: usize = 2;181	pub const MaxAssetsForTransfer: usize = 2;
182
183	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
184	pub SelfLocation: MultiLocation = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
232}185}
233186
234parameter_type_with_key! {187parameter_type_with_key! {
237	};190	};
238}191}
239192
193pub fn get_all_module_accounts() -> Vec<AccountId> {
194	vec![TreasuryModuleId::get().into_account_truncating()]
195}
240pub struct AccountIdToMultiLocation;196pub struct AccountIdToMultiLocation;
241impl Convert<AccountId, MultiLocation> for AccountIdToMultiLocation {197impl Convert<AccountId, MultiLocation> for AccountIdToMultiLocation {
242	fn convert(account: AccountId) -> MultiLocation {198	fn convert(account: AccountId) -> MultiLocation {
248	}204	}
249}205}
250
251impl orml_xtokens::Config for Runtime {
252	type Event = Event;
253	type Balance = Balance;
254	type CurrencyId = CurrencyId;
255	type CurrencyIdConvert = CurrencyIdConvert;
256	type AccountIdToMultiLocation = AccountIdToMultiLocation;
257	type SelfLocation = SelfLocation;
258	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
259	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
260	type BaseXcmWeight = BaseXcmWeight;
261	type LocationInverter = LocationInverter<Ancestry>;
262	type MaxAssetsForTransfer = MaxAssetsForTransfer;
263	type MinXcmFee = ParachainMinFee;
264	type MultiLocationsFilter = Everything;
265	type ReserveProvider = AbsoluteReserveProvider;
266}
267206

--- a/runtime/quartz/src/tests/logcapture.rs
+++ b/runtime/quartz/src/tests/logcapture.rs
@@ -19,7 +19,7 @@
 
 #[test]
 fn quartz_log_capture_tests() {
-    let mut logger = Logger::start();
-    
-    quartz_xcm_tests(&mut logger);
+	let mut logger = Logger::start();
+
+	quartz_xcm_tests(&mut logger);
 }

--- a/runtime/quartz/src/tests/mod.rs
+++ b/runtime/quartz/src/tests/mod.rs
@@ -14,5 +14,5 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+mod logcapture;
 mod xcm;
-mod logcapture;

--- a/runtime/quartz/src/tests/xcm.rs
+++ b/runtime/quartz/src/tests/xcm.rs
@@ -15,18 +15,13 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 use logtest::Logger;
-use crate::{
-    runtime_common::tests::xcm::*,
-    xcm_config::Barrier,
-};
+use crate::{runtime_common::tests::xcm::*, xcm_config::Barrier};
 
 const QUARTZ_PARA_ID: u32 = 2095;
 
 pub fn quartz_xcm_tests(logger: &mut Logger) {
-    barrier_denies_transact::<Barrier>(logger);
+	barrier_denies_transact::<Barrier>(logger);
 
-    barrier_denies_transfer_from_unknown_location::<Barrier>(
-        logger,
-        QUARTZ_PARA_ID,
-    ).expect("quartz runtime denies an unknown location");
+	barrier_denies_transfer_from_unknown_location::<Barrier>(logger, QUARTZ_PARA_ID)
+		.expect("quartz runtime denies an unknown location");
 }

--- a/runtime/quartz/src/xcm_config.rs
+++ b/runtime/quartz/src/xcm_config.rs
@@ -14,53 +14,31 @@
 // 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 cumulus_pallet_xcm;
 use frame_support::{
-    {match_types, parameter_types, weights::Weight},
-    pallet_prelude::Get,
-    traits::{Contains, Everything, fungibles},
+	{match_types, parameter_types, weights::Weight},
+	pallet_prelude::Get,
+	traits::{Contains, Everything},
 };
-use frame_system::EnsureRoot;
 use orml_traits::{location::AbsoluteReserveProvider, parameter_type_with_key};
-use pallet_xcm::XcmPassthrough;
-use polkadot_parachain::primitives::Sibling;
-use sp_runtime::traits::{AccountIdConversion, CheckedConversion, Convert, Zero};
-use sp_std::{borrow::Borrow, marker::PhantomData, vec, vec::Vec};
+use sp_runtime::traits::{AccountIdConversion, Convert};
+use sp_std::{vec, vec::Vec};
 use xcm::{
-    latest::{MultiAsset, Xcm},
-    prelude::{Concrete, Fungible as XcmFungible},
-    v1::{BodyId, Junction::*, Junctions::*, MultiLocation, NetworkId},
+	latest::Xcm,
+	v1::{BodyId, Junction::*, Junctions::*, MultiLocation, NetworkId},
 };
 use xcm_builder::{
-    AllowKnownQueryResponses, AllowSubscriptionsFrom,
-    AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom,
-    EnsureXcmOrigin, FixedWeightBounds, FungiblesAdapter, LocationInverter, ParentAsSuperuser,
-    ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
-    SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
-    ConvertedConcreteAssetId,
+	AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom,
+	AllowUnpaidExecutionFrom, FixedWeightBounds, LocationInverter, TakeWeightCredit,
 };
-use xcm_executor::{
-    {Config, XcmExecutor},
-    traits::{Convert as ConvertXcm, FilterAssetLocation, JustTry, MatchesFungible},
-};
+use xcm_executor::XcmExecutor;
 
-use up_common::{
-    constants::{MAXIMUM_BLOCK_WEIGHT, UNIQUE},
-    types::{AccountId, Balance},
-};
-use pallet_foreing_assets::{
-    AssetIds, AssetIdMapping, XcmForeignAssetIdMapping, CurrencyId, NativeCurrency,
-    FreeForAll, TryAsForeing, ForeignAssetId,
-};
-use crate::{
-    Balances, Call, DmpQueue, Event, Origin, ParachainInfo,
-    ParachainSystem, PolkadotXcm, Runtime, XcmpQueue,
-};
+use up_common::types::{AccountId, Balance};
+use pallet_foreing_assets::{AssetIds, CurrencyId, NativeCurrency};
+use crate::{Call, Event, ParachainInfo, PolkadotXcm, Runtime};
 use crate::runtime_common::config::substrate::{TreasuryModuleId, MaxLocks, MaxReserves};
 use crate::runtime_common::config::pallets::TreasuryAccountId;
 use crate::runtime_common::config::xcm::*;
-use crate::*;
-use xcm::opaque::latest::prelude::{ DepositReserveAsset, DepositAsset, TransferAsset, TransferReserveAsset };
+use xcm::opaque::latest::prelude::{DepositReserveAsset, TransferReserveAsset};
 
 // Signed version of balance
 pub type Amount = i128;
@@ -76,103 +54,113 @@
 	};
 }
 
+pub type Barrier = DenyThenTry<
+	(DenyTransact, DenyExchangeWithUnknownLocation),
+	(
+		TakeWeightCredit,
+		AllowTopLevelPaidExecutionFrom<Everything>,
+		// Parent and its exec plurality get free execution
+		AllowUnpaidExecutionFrom<ParentOrParentsExecutivePlurality>,
+		// Expected responses are OK.
+		AllowKnownQueryResponses<PolkadotXcm>,
+		// Subscriptions for version tracking are OK.
+		AllowSubscriptionsFrom<ParentOrSiblings>,
+	),
+>;
+
 pub fn get_allowed_locations() -> Vec<MultiLocation> {
-    vec![
-        // Self location
-        MultiLocation { parents: 0, interior: Here },
-        // Parent location
-        MultiLocation { parents: 1, interior: Here },
-        // Karura/Acala location
-        MultiLocation { parents: 1, interior: X1(Parachain(2000)) },
-        // Moonriver location
-        MultiLocation { parents: 1, interior: X1(Parachain(2023)) },
-        // Self parachain address
-        MultiLocation { parents: 1, interior: X1(Parachain(ParachainInfo::get().into())) },
-    ]
+	vec![
+		// Self location
+		MultiLocation {
+			parents: 0,
+			interior: Here,
+		},
+		// Parent location
+		MultiLocation {
+			parents: 1,
+			interior: Here,
+		},
+		// Karura/Acala location
+		MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(2000)),
+		},
+		// Moonriver location
+		MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(2023)),
+		},
+		// Self parachain address
+		MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(ParachainInfo::get().into())),
+		},
+	]
 }
 
 // Allow xcm exchange only with locations in list
 pub struct DenyExchangeWithUnknownLocation;
 impl TryPass for DenyExchangeWithUnknownLocation {
-    fn try_pass<Call>(
-        origin: &MultiLocation,
-        message: &mut Xcm<Call>,
-    ) -> Result<(), ()> {
+	fn try_pass<Call>(origin: &MultiLocation, message: &mut Xcm<Call>) -> Result<(), ()> {
+		// Check if deposit or transfer belongs to allowed parachains
+		let mut allowed = get_allowed_locations().contains(origin);
 
-        // Check if deposit or transfer belongs to allowed parachains
-        let mut allowed = get_allowed_locations().contains(origin);
+		message.0.iter().for_each(|inst| match inst {
+			DepositReserveAsset { dest: dst, .. } => {
+				allowed |= get_allowed_locations().contains(dst);
+			}
+			TransferReserveAsset { dest: dst, .. } => {
+				allowed |= get_allowed_locations().contains(dst);
+			}
+			_ => {}
+		});
 
-        message.0.iter().for_each(|inst| {
-            match inst {
-                DepositReserveAsset { dest: dst, .. } => { allowed |= get_allowed_locations().contains(dst); }
-                TransferReserveAsset { dest: dst, .. } => { allowed |= get_allowed_locations().contains(dst); }
-                _ => {}
-            }
-        });
+		if allowed {
+			return Ok(());
+		}
 
-        if allowed {
-            return Ok(());
-        }
-
-        log::warn!(
+		log::warn!(
 			target: "xcm::barrier",
 			"Unexpected deposit or transfer location"
 		);
-        // Deny
-        Err(())
-    }
+		// Deny
+		Err(())
+	}
 }
 
-pub type Barrier = DenyThenTry<
-    (
-        DenyTransact,
-        DenyExchangeWithUnknownLocation,
-    ),
-    (
-        TakeWeightCredit,
-        AllowTopLevelPaidExecutionFrom<Everything>,
-        // Parent and its exec plurality get free execution
-        AllowUnpaidExecutionFrom<ParentOrParentsExecutivePlurality>,
-        // Expected responses are OK.
-        AllowKnownQueryResponses<PolkadotXcm>,
-        // Subscriptions for version tracking are OK.
-        AllowSubscriptionsFrom<ParentOrSiblings>,
-    ),
->;
-
 impl orml_tokens::Config for Runtime {
-    type Event = Event;
-    type Balance = Balance;
-    type Amount = Amount;
-    type CurrencyId = CurrencyId;
-    type WeightInfo = ();
-    type ExistentialDeposits = ExistentialDeposits;
-    type OnDust = orml_tokens::TransferDust<Runtime, TreasuryAccountId>;
-    type MaxLocks = MaxLocks;
-    type MaxReserves = MaxReserves;
-    // TODO: Add all module accounts
-    type DustRemovalWhitelist = DustRemovalWhitelist;
-    /// The id type for named reserves.
-    type ReserveIdentifier = ();
-    type OnNewTokenAccount = ();
-    type OnKilledTokenAccount = ();
+	type Event = Event;
+	type Balance = Balance;
+	type Amount = Amount;
+	type CurrencyId = CurrencyId;
+	type WeightInfo = ();
+	type ExistentialDeposits = ExistentialDeposits;
+	type OnDust = orml_tokens::TransferDust<Runtime, TreasuryAccountId>;
+	type MaxLocks = MaxLocks;
+	type MaxReserves = MaxReserves;
+	// TODO: Add all module accounts
+	type DustRemovalWhitelist = DustRemovalWhitelist;
+	/// The id type for named reserves.
+	type ReserveIdentifier = ();
+	type OnNewTokenAccount = ();
+	type OnKilledTokenAccount = ();
 }
 
 impl orml_xtokens::Config for Runtime {
-    type Event = Event;
-    type Balance = Balance;
-    type CurrencyId = CurrencyId;
-    type CurrencyIdConvert = CurrencyIdConvert;
-    type AccountIdToMultiLocation = AccountIdToMultiLocation;
-    type SelfLocation = SelfLocation;
-    type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
-    type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
-    type BaseXcmWeight = BaseXcmWeight;
-    type LocationInverter = LocationInverter<Ancestry>;
-    type MaxAssetsForTransfer = MaxAssetsForTransfer;
-    type MinXcmFee = ParachainMinFee;
-    type MultiLocationsFilter = Everything;
-    type ReserveProvider = AbsoluteReserveProvider;
+	type Event = Event;
+	type Balance = Balance;
+	type CurrencyId = CurrencyId;
+	type CurrencyIdConvert = CurrencyIdConvert;
+	type AccountIdToMultiLocation = AccountIdToMultiLocation;
+	type SelfLocation = SelfLocation;
+	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
+	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
+	type BaseXcmWeight = BaseXcmWeight;
+	type LocationInverter = LocationInverter<Ancestry>;
+	type MaxAssetsForTransfer = MaxAssetsForTransfer;
+	type MinXcmFee = ParachainMinFee;
+	type MultiLocationsFilter = Everything;
+	type ReserveProvider = AbsoluteReserveProvider;
 }
 
 parameter_type_with_key! {
@@ -189,34 +177,28 @@
 
 pub struct DustRemovalWhitelist;
 impl Contains<AccountId> for DustRemovalWhitelist {
-    fn contains(a: &AccountId) -> bool {
-        get_all_module_accounts().contains(a)
-    }
+	fn contains(a: &AccountId) -> bool {
+		get_all_module_accounts().contains(a)
+	}
 }
 
 pub struct CurrencyIdConvert;
 impl Convert<AssetIds, Option<MultiLocation>> for CurrencyIdConvert {
-    fn convert(id: AssetIds) -> Option<MultiLocation> {
-        match id {
-            AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
-                1,
-                X1(Parachain(ParachainInfo::get().into())),
-            )),
-            AssetIds::NativeAssetId(NativeCurrency::Parent) => Some(MultiLocation::parent()),
-            AssetIds::ForeignAssetId(_) => None,
-        }
-    }
+	fn convert(id: AssetIds) -> Option<MultiLocation> {
+		match id {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
+				1,
+				X1(Parachain(ParachainInfo::get().into())),
+			)),
+			_ => None,
+		}
+	}
 }
 
 parameter_types! {
 	pub const BaseXcmWeight: Weight = 100_000_000; // TODO: recheck this
 	pub const MaxAssetsForTransfer: usize = 2;
-}
 
-parameter_types! {
-	pub const RelayLocation: MultiLocation = MultiLocation::parent();
-	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;
-	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();
 	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
 	pub SelfLocation: MultiLocation = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
 }
@@ -228,16 +210,16 @@
 }
 
 pub fn get_all_module_accounts() -> Vec<AccountId> {
-    vec![TreasuryModuleId::get().into_account_truncating()]
+	vec![TreasuryModuleId::get().into_account_truncating()]
 }
 
 pub struct AccountIdToMultiLocation;
 impl Convert<AccountId, MultiLocation> for AccountIdToMultiLocation {
-    fn convert(account: AccountId) -> MultiLocation {
-        X1(AccountId32 {
-            network: NetworkId::Any,
-            id: account.into(),
-        })
-            .into()
-    }
+	fn convert(account: AccountId) -> MultiLocation {
+		X1(AccountId32 {
+			network: NetworkId::Any,
+			id: account.into(),
+		})
+		.into()
+	}
 }

--- a/runtime/unique/src/tests/logcapture.rs
+++ b/runtime/unique/src/tests/logcapture.rs
@@ -19,7 +19,7 @@
 
 #[test]
 fn unique_log_capture_tests() {
-    let mut logger = Logger::start();
-    
-    unique_xcm_tests(&mut logger);
+	let mut logger = Logger::start();
+
+	unique_xcm_tests(&mut logger);
 }

--- a/runtime/unique/src/tests/mod.rs
+++ b/runtime/unique/src/tests/mod.rs
@@ -14,5 +14,5 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+mod logcapture;
 mod xcm;
-mod logcapture;

--- a/runtime/unique/src/tests/xcm.rs
+++ b/runtime/unique/src/tests/xcm.rs
@@ -15,18 +15,13 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 use logtest::Logger;
-use crate::{
-    runtime_common::tests::xcm::*,
-    xcm_config::Barrier,
-};
+use crate::{runtime_common::tests::xcm::*, xcm_config::Barrier};
 
 const UNIQUE_PARA_ID: u32 = 2037;
 
 pub fn unique_xcm_tests(logger: &mut Logger) {
-    barrier_denies_transact::<Barrier>(logger);
+	barrier_denies_transact::<Barrier>(logger);
 
-    barrier_denies_transfer_from_unknown_location::<Barrier>(
-        logger,
-        UNIQUE_PARA_ID,
-    ).expect("unique runtime denies an unknown location");
+	barrier_denies_transfer_from_unknown_location::<Barrier>(logger, UNIQUE_PARA_ID)
+		.expect("unique runtime denies an unknown location");
 }

--- a/runtime/unique/src/xcm_config.rs
+++ b/runtime/unique/src/xcm_config.rs
@@ -14,143 +14,153 @@
 // 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 cumulus_pallet_xcm;
 use frame_support::{
-    {match_types, parameter_types, weights::Weight},
-    pallet_prelude::Get,
-    traits::{Contains, Everything, fungibles},
+	{match_types, parameter_types, weights::Weight},
+	pallet_prelude::Get,
+	traits::{Contains, Everything},
 };
-use frame_system::EnsureRoot;
 use orml_traits::{location::AbsoluteReserveProvider, parameter_type_with_key};
-use pallet_xcm::XcmPassthrough;
-use polkadot_parachain::primitives::Sibling;
-use sp_runtime::traits::{AccountIdConversion, CheckedConversion, Convert, Zero};
-use sp_std::{borrow::Borrow, marker::PhantomData, vec, vec::Vec};
+use sp_runtime::traits::{AccountIdConversion, Convert};
+use sp_std::{vec, vec::Vec};
 use xcm::{
-    latest::{MultiAsset, Xcm},
-    prelude::{Concrete, Fungible as XcmFungible},
-    v1::{BodyId, Junction::*, Junctions::*, MultiLocation, NetworkId},
+	latest::Xcm,
+	v1::{BodyId, Junction::*, Junctions::*, MultiLocation, NetworkId},
 };
 use xcm_builder::{
-    AllowKnownQueryResponses, AllowSubscriptionsFrom,
-    AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom,
-    EnsureXcmOrigin, FixedWeightBounds, FungiblesAdapter, LocationInverter, ParentAsSuperuser,
-    ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
-    SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
-    ConvertedConcreteAssetId,
+	AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom,
+	AllowUnpaidExecutionFrom, FixedWeightBounds, LocationInverter, TakeWeightCredit,
 };
-use xcm_executor::{
-    {Config, XcmExecutor},
-    traits::{Convert as ConvertXcm, FilterAssetLocation, JustTry, MatchesFungible},
-};
+use xcm_executor::XcmExecutor;
 
-use up_common::{
-    constants::{MAXIMUM_BLOCK_WEIGHT, UNIQUE},
-    types::{AccountId, Balance},
-};
-use pallet_foreing_assets::{
-    AssetIds, AssetIdMapping, XcmForeignAssetIdMapping, CurrencyId, NativeCurrency,
-    FreeForAll, TryAsForeing, ForeignAssetId,
-};
-use crate::{
-    Balances, Call, DmpQueue, Event, Origin, ParachainInfo,
-    ParachainSystem, PolkadotXcm, Runtime, XcmpQueue,
-};
+use up_common::types::{AccountId, Balance};
+use pallet_foreing_assets::{AssetIds, CurrencyId, NativeCurrency};
+use crate::{Call, Event, ParachainInfo, PolkadotXcm, Runtime};
 use crate::runtime_common::config::substrate::{TreasuryModuleId, MaxLocks, MaxReserves};
 use crate::runtime_common::config::pallets::TreasuryAccountId;
 use crate::runtime_common::config::xcm::*;
-use crate::*;
-use xcm::opaque::latest::prelude::{ DepositReserveAsset, DepositAsset, TransferAsset, TransferReserveAsset };
+use xcm::opaque::latest::prelude::{DepositReserveAsset, TransferReserveAsset};
 
 // Signed version of balance
 pub type Amount = i128;
 
+match_types! {
+	pub type ParentOrParentsExecutivePlurality: impl Contains<MultiLocation> = {
+		MultiLocation { parents: 1, interior: Here } |
+		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Executive, .. }) }
+	};
+	pub type ParentOrSiblings: impl Contains<MultiLocation> = {
+		MultiLocation { parents: 1, interior: Here } |
+		MultiLocation { parents: 1, interior: X1(_) }
+	};
+}
 
 pub type Barrier = DenyThenTry<
-    (
-        DenyTransact,
-        DenyExchangeWithUnknownLocation,
-    ),
-    (
-        TakeWeightCredit,
-        AllowTopLevelPaidExecutionFrom<Everything>,
-        // Parent and its exec plurality get free execution
-        AllowUnpaidExecutionFrom<ParentOrParentsExecutivePlurality>,
-        // Expected responses are OK.
-        AllowKnownQueryResponses<PolkadotXcm>,
-        // Subscriptions for version tracking are OK.
-        AllowSubscriptionsFrom<ParentOrSiblings>,
-    ),
+	(DenyTransact, DenyExchangeWithUnknownLocation),
+	(
+		TakeWeightCredit,
+		AllowTopLevelPaidExecutionFrom<Everything>,
+		// Parent and its exec plurality get free execution
+		AllowUnpaidExecutionFrom<ParentOrParentsExecutivePlurality>,
+		// Expected responses are OK.
+		AllowKnownQueryResponses<PolkadotXcm>,
+		// Subscriptions for version tracking are OK.
+		AllowSubscriptionsFrom<ParentOrSiblings>,
+	),
 >;
 
 pub fn get_allowed_locations() -> Vec<MultiLocation> {
-    vec![
-        // Self location
-        MultiLocation { parents: 0, interior: Here },
-        // Parent location
-        MultiLocation { parents: 1, interior: Here },
-        // Karura/Acala location
-        MultiLocation { parents: 1, interior: X1(Parachain(2000)) },
-        // Moonbeam location
-        MultiLocation { parents: 1, interior: X1(Parachain(2004)) },
-        // Self parachain address
-        MultiLocation { parents: 1, interior: X1(Parachain(ParachainInfo::get().into())) },
-    ]
+	vec![
+		// Self location
+		MultiLocation {
+			parents: 0,
+			interior: Here,
+		},
+		// Parent location
+		MultiLocation {
+			parents: 1,
+			interior: Here,
+		},
+		// Karura/Acala location
+		MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(2000)),
+		},
+		// Moonbeam location
+		MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(2004)),
+		},
+		// Self parachain address
+		MultiLocation {
+			parents: 1,
+			interior: X1(Parachain(ParachainInfo::get().into())),
+		},
+	]
 }
 
 // Allow xcm exchange only with locations in list
 pub struct DenyExchangeWithUnknownLocation;
 impl TryPass for DenyExchangeWithUnknownLocation {
-    fn try_pass<Call>(
-        origin: &MultiLocation,
-        message: &mut Xcm<Call>,
-    ) -> Result<(), ()> {
+	fn try_pass<Call>(origin: &MultiLocation, message: &mut Xcm<Call>) -> Result<(), ()> {
+		// Check if deposit or transfer belongs to allowed parachains
+		let mut allowed = get_allowed_locations().contains(origin);
 
-        // Check if deposit or transfer belongs to allowed parachains
-        let mut allowed = get_allowed_locations().contains(origin);
-
-        message.0.iter().for_each(|inst| {
-            match inst {
-                DepositReserveAsset { dest: dst, .. } => { allowed |= get_allowed_locations().contains(dst); }
-                TransferReserveAsset { dest: dst, .. } => { allowed |= get_allowed_locations().contains(dst); }
-                _ => {}
-            }
-        });
+		message.0.iter().for_each(|inst| match inst {
+			DepositReserveAsset { dest: dst, .. } => {
+				allowed |= get_allowed_locations().contains(dst);
+			}
+			TransferReserveAsset { dest: dst, .. } => {
+				allowed |= get_allowed_locations().contains(dst);
+			}
+			_ => {}
+		});
 
-        if allowed {
-            return Ok(());
-        }
+		if allowed {
+			return Ok(());
+		}
 
-        log::warn!(
+		log::warn!(
 			target: "xcm::barrier",
 			"Unexpected deposit or transfer location"
 		);
-        // Deny
-        Err(())
-    }
-}
-
-
-match_types! {
-	pub type ParentOrParentsExecutivePlurality: impl Contains<MultiLocation> = {
-		MultiLocation { parents: 1, interior: Here } |
-		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Executive, .. }) }
-	};
-	pub type ParentOrSiblings: impl Contains<MultiLocation> = {
-		MultiLocation { parents: 1, interior: Here } |
-		MultiLocation { parents: 1, interior: X1(_) }
-	};
+		// Deny
+		Err(())
+	}
 }
 
-pub fn get_all_module_accounts() -> Vec<AccountId> {
-    vec![TreasuryModuleId::get().into_account_truncating()]
+impl orml_tokens::Config for Runtime {
+	type Event = Event;
+	type Balance = Balance;
+	type Amount = Amount;
+	type CurrencyId = CurrencyId;
+	type WeightInfo = ();
+	type ExistentialDeposits = ExistentialDeposits;
+	type OnDust = orml_tokens::TransferDust<Runtime, TreasuryAccountId>;
+	type MaxLocks = MaxLocks;
+	type MaxReserves = MaxReserves;
+	// TODO: Add all module accounts
+	type DustRemovalWhitelist = DustRemovalWhitelist;
+	/// The id type for named reserves.
+	type ReserveIdentifier = ();
+	type OnNewTokenAccount = ();
+	type OnKilledTokenAccount = ();
 }
 
-pub struct DustRemovalWhitelist;
-impl Contains<AccountId> for DustRemovalWhitelist {
-    fn contains(a: &AccountId) -> bool {
-        get_all_module_accounts().contains(a)
-    }
+impl orml_xtokens::Config for Runtime {
+	type Event = Event;
+	type Balance = Balance;
+	type CurrencyId = CurrencyId;
+	type CurrencyIdConvert = CurrencyIdConvert;
+	type AccountIdToMultiLocation = AccountIdToMultiLocation;
+	type SelfLocation = SelfLocation;
+	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
+	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
+	type BaseXcmWeight = BaseXcmWeight;
+	type LocationInverter = LocationInverter<Ancestry>;
+	type MaxAssetsForTransfer = MaxAssetsForTransfer;
+	type MinXcmFee = ParachainMinFee;
+	type MultiLocationsFilter = Everything;
+	type ReserveProvider = AbsoluteReserveProvider;
 }
 
 parameter_type_with_key! {
@@ -165,60 +175,32 @@
 	};
 }
 
-impl orml_tokens::Config for Runtime {
-    type Event = Event;
-    type Balance = Balance;
-    type Amount = Amount;
-    type CurrencyId = CurrencyId;
-    type WeightInfo = ();
-    type ExistentialDeposits = ExistentialDeposits;
-    type OnDust = orml_tokens::TransferDust<Runtime, TreasuryAccountId>;
-    type MaxLocks = MaxLocks;
-    type MaxReserves = MaxReserves;
-    // TODO: Add all module accounts
-    type DustRemovalWhitelist = DustRemovalWhitelist;
-    /// The id type for named reserves.
-    type ReserveIdentifier = ();
-    type OnNewTokenAccount = ();
-    type OnKilledTokenAccount = ();
-}
-
-impl orml_xtokens::Config for Runtime {
-    type Event = Event;
-    type Balance = Balance;
-    type CurrencyId = CurrencyId;
-    type CurrencyIdConvert = CurrencyIdConvert;
-    type AccountIdToMultiLocation = AccountIdToMultiLocation;
-    type SelfLocation = SelfLocation;
-    type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
-    type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
-    type BaseXcmWeight = BaseXcmWeight;
-    type LocationInverter = LocationInverter<Ancestry>;
-    type MaxAssetsForTransfer = MaxAssetsForTransfer;
-    type MinXcmFee = ParachainMinFee;
-    type MultiLocationsFilter = Everything;
-    type ReserveProvider = AbsoluteReserveProvider;
+pub struct DustRemovalWhitelist;
+impl Contains<AccountId> for DustRemovalWhitelist {
+	fn contains(a: &AccountId) -> bool {
+		get_all_module_accounts().contains(a)
+	}
 }
 
 pub struct CurrencyIdConvert;
 impl Convert<AssetIds, Option<MultiLocation>> for CurrencyIdConvert {
-    fn convert(id: AssetIds) -> Option<MultiLocation> {
-        match id {
-            AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
-                1,
-                X1(Parachain(ParachainInfo::get().into())),
-            )),
-            _ => None,
-        }
-    }
+	fn convert(id: AssetIds) -> Option<MultiLocation> {
+		match id {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
+				1,
+				X1(Parachain(ParachainInfo::get().into())),
+			)),
+			_ => None,
+		}
+	}
 }
 
 parameter_types! {
 	pub const BaseXcmWeight: Weight = 100_000_000; // TODO: recheck this
 	pub const MaxAssetsForTransfer: usize = 2;
 
-    pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
-    pub SelfLocation: MultiLocation = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
+	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
+	pub SelfLocation: MultiLocation = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
 }
 
 parameter_type_with_key! {
@@ -227,14 +209,17 @@
 	};
 }
 
+pub fn get_all_module_accounts() -> Vec<AccountId> {
+	vec![TreasuryModuleId::get().into_account_truncating()]
+}
 
 pub struct AccountIdToMultiLocation;
 impl Convert<AccountId, MultiLocation> for AccountIdToMultiLocation {
-    fn convert(account: AccountId) -> MultiLocation {
-        X1(AccountId32 {
-            network: NetworkId::Any,
-            id: account.into(),
-        })
-            .into()
-    }
+	fn convert(account: AccountId) -> MultiLocation {
+		X1(AccountId32 {
+			network: NetworkId::Any,
+			id: account.into(),
+		})
+		.into()
+	}
 }