Refactoring Checkpoint: (WIP)

pezkuwi/xcm/xcm-pez-simulator/example/Cargo.toml

@@ -0,0 +1,61 @@
+[package]
+name = "xcm-pez-simulator-example"
+description = "Examples of xcm-pez-simulator usage."
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+version = "7.0.0"
+homepage.workspace = true
+repository.workspace = true
+documentation = "https://docs.rs/xcm-pez-simulator-example"
+publish = false
+
+[lints]
+workspace = true
+
+[dependencies]
+codec = { workspace = true, default-features = true }
+scale-info = { features = [
+  "derive",
+], workspace = true, default-features = true }
+tracing = { workspace = true }
+
+pezframe-support = { workspace = true, default-features = true }
+pezframe-system = { workspace = true, default-features = true }
+pezpallet-balances = { workspace = true, default-features = true }
+pezpallet-message-queue = { workspace = true, default-features = true }
+pezpallet-uniques = { workspace = true, default-features = true }
+pezsp-core = { workspace = true, default-features = true }
+pezsp-io = { workspace = true, default-features = true }
+pezsp-runtime = { workspace = true, default-features = true }
+pezsp-tracing = { workspace = true, default-features = true }
+
+pezpallet-xcm = { workspace = true, default-features = true }
+pezkuwi-runtime-teyrchains = { workspace = true, default-features = true }
+pezkuwi-teyrchain-primitives = { workspace = true, default-features = true }
+xcm = { workspace = true, default-features = true }
+xcm-builder = { workspace = true, default-features = true }
+xcm-executor = { workspace = true, default-features = true }
+xcm-pez-simulator = { workspace = true, default-features = true }
+
+[dev-dependencies]
+pezsp-tracing = { workspace = true }
+
+[features]
+default = []
+runtime-benchmarks = [
+  "pezframe-support/runtime-benchmarks",
+  "pezframe-system/runtime-benchmarks",
+  "pezpallet-balances/runtime-benchmarks",
+  "pezpallet-message-queue/runtime-benchmarks",
+  "pezpallet-uniques/runtime-benchmarks",
+  "pezpallet-xcm/runtime-benchmarks",
+  "pezkuwi-runtime-teyrchains/runtime-benchmarks",
+  "pezkuwi-teyrchain-primitives/runtime-benchmarks",
+  "pezsp-io/runtime-benchmarks",
+  "pezsp-runtime/runtime-benchmarks",
+  "xcm-builder/runtime-benchmarks",
+  "xcm-executor/runtime-benchmarks",
+  "xcm-pez-simulator/runtime-benchmarks",
+  "xcm/runtime-benchmarks",
+]

pezkuwi/xcm/xcm-pez-simulator/example/src/lib.rs

@@ -0,0 +1,149 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+// We do not declare all features used by `construct_runtime`
+#[allow(unexpected_cfgs)]
+mod teyrchain;
+
+// We do not declare all features used by `construct_runtime`
+#[allow(unexpected_cfgs)]
+mod relay_chain;
+
+#[cfg(test)]
+mod tests;
+
+use pezsp_runtime::BuildStorage;
+use pezsp_tracing;
+use xcm::prelude::*;
+use xcm_executor::traits::ConvertLocation;
+use xcm_pez_simulator::{decl_test_network, decl_test_relay_chain, decl_test_teyrchain, TestExt};
+
+pub const ALICE: pezsp_runtime::AccountId32 = pezsp_runtime::AccountId32::new([1u8; 32]);
+pub const INITIAL_BALANCE: u128 = 1_000_000_000;
+
+decl_test_teyrchain! {
+	pub struct ParaA {
+		Runtime = teyrchain::Runtime,
+		XcmpMessageHandler = teyrchain::MsgQueue,
+		DmpMessageHandler = teyrchain::MsgQueue,
+		new_ext = para_ext(1),
+	}
+}
+
+decl_test_teyrchain! {
+	pub struct ParaB {
+		Runtime = teyrchain::Runtime,
+		XcmpMessageHandler = teyrchain::MsgQueue,
+		DmpMessageHandler = teyrchain::MsgQueue,
+		new_ext = para_ext(2),
+	}
+}
+
+decl_test_relay_chain! {
+	pub struct Relay {
+		Runtime = relay_chain::Runtime,
+		RuntimeCall = relay_chain::RuntimeCall,
+		RuntimeEvent = relay_chain::RuntimeEvent,
+		XcmConfig = relay_chain::XcmConfig,
+		MessageQueue = relay_chain::MessageQueue,
+		System = relay_chain::System,
+		new_ext = relay_ext(),
+	}
+}
+
+decl_test_network! {
+	pub struct MockNet {
+		relay_chain = Relay,
+		teyrchains = vec![
+			(1, ParaA),
+			(2, ParaB),
+		],
+	}
+}
+
+pub fn parent_account_id() -> teyrchain::AccountId {
+	let location = (Parent,);
+	teyrchain::location_converter::LocationConverter::convert_location(&location.into()).unwrap()
+}
+
+pub fn child_account_id(para: u32) -> relay_chain::AccountId {
+	let location = (Teyrchain(para),);
+	relay_chain::location_converter::LocationConverter::convert_location(&location.into()).unwrap()
+}
+
+pub fn child_account_account_id(para: u32, who: pezsp_runtime::AccountId32) -> relay_chain::AccountId {
+	let location = (Teyrchain(para), AccountId32 { network: None, id: who.into() });
+	relay_chain::location_converter::LocationConverter::convert_location(&location.into()).unwrap()
+}
+
+pub fn sibling_account_account_id(para: u32, who: pezsp_runtime::AccountId32) -> teyrchain::AccountId {
+	let location = (Parent, Teyrchain(para), AccountId32 { network: None, id: who.into() });
+	teyrchain::location_converter::LocationConverter::convert_location(&location.into()).unwrap()
+}
+
+pub fn parent_account_account_id(who: pezsp_runtime::AccountId32) -> teyrchain::AccountId {
+	let location = (Parent, AccountId32 { network: None, id: who.into() });
+	teyrchain::location_converter::LocationConverter::convert_location(&location.into()).unwrap()
+}
+
+pub fn para_ext(para_id: u32) -> pezsp_io::TestExternalities {
+	use teyrchain::{MsgQueue, Runtime, System};
+
+	let mut t = pezframe_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+	pezpallet_balances::GenesisConfig::<Runtime> {
+		balances: vec![(ALICE, INITIAL_BALANCE), (parent_account_id(), INITIAL_BALANCE)],
+		..Default::default()
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	let mut ext = pezsp_io::TestExternalities::new(t);
+	ext.execute_with(|| {
+		pezsp_tracing::try_init_simple();
+		System::set_block_number(1);
+		MsgQueue::set_para_id(para_id.into());
+	});
+	ext
+}
+
+pub fn relay_ext() -> pezsp_io::TestExternalities {
+	use relay_chain::{Runtime, RuntimeOrigin, System, Uniques};
+
+	let mut t = pezframe_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+	pezpallet_balances::GenesisConfig::<Runtime> {
+		balances: vec![
+			(ALICE, INITIAL_BALANCE),
+			(child_account_id(1), INITIAL_BALANCE),
+			(child_account_id(2), INITIAL_BALANCE),
+		],
+		..Default::default()
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	let mut ext = pezsp_io::TestExternalities::new(t);
+	ext.execute_with(|| {
+		System::set_block_number(1);
+		assert_eq!(Uniques::force_create(RuntimeOrigin::root(), 1, ALICE, true), Ok(()));
+		assert_eq!(Uniques::mint(RuntimeOrigin::signed(ALICE), 1, 42, child_account_id(1)), Ok(()));
+	});
+	ext
+}
+
+pub type RelayChainPalletXcm = pezpallet_xcm::Pallet<relay_chain::Runtime>;
+pub type TeyrchainPalletXcm = pezpallet_xcm::Pallet<teyrchain::Runtime>;

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/mod.rs

@@ -0,0 +1,182 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Relay chain runtime mock.
+
+mod xcm_config;
+pub use xcm_config::*;
+
+use pezframe_support::{
+	construct_runtime, derive_impl, parameter_types,
+	traits::{
+		AsEnsureOriginWithArg, ConstU128, Disabled, Everything, Nothing, ProcessMessage,
+		ProcessMessageError,
+	},
+	weights::{Weight, WeightMeter},
+};
+
+use pezframe_system::EnsureRoot;
+use pezsp_core::ConstU32;
+use pezsp_runtime::{traits::IdentityLookup, AccountId32};
+
+use pezkuwi_runtime_teyrchains::{
+	configuration,
+	inclusion::{AggregateMessageOrigin, UmpQueueId},
+	origin, shared,
+};
+use xcm::latest::prelude::*;
+use xcm_builder::{IsConcrete, SignedToAccountId32};
+use xcm_executor::XcmExecutor;
+
+pub type AccountId = AccountId32;
+pub type Balance = u128;
+
+parameter_types! {
+	pub const BlockHashCount: u64 = 250;
+}
+
+#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+impl pezframe_system::Config for Runtime {
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type AccountData = pezpallet_balances::AccountData<Balance>;
+}
+
+#[derive_impl(pezpallet_balances::config_preludes::TestDefaultConfig)]
+impl pezpallet_balances::Config for Runtime {
+	type Balance = Balance;
+	type ExistentialDeposit = ConstU128<1>;
+	type AccountStore = System;
+}
+
+impl pezpallet_uniques::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<pezframe_system::EnsureSigned<AccountId>>;
+	type ForceOrigin = pezframe_system::EnsureRoot<AccountId>;
+	type CollectionDeposit = pezframe_support::traits::ConstU128<1_000>;
+	type ItemDeposit = pezframe_support::traits::ConstU128<1_000>;
+	type MetadataDepositBase = pezframe_support::traits::ConstU128<1_000>;
+	type AttributeDepositBase = pezframe_support::traits::ConstU128<1_000>;
+	type DepositPerByte = pezframe_support::traits::ConstU128<1>;
+	type StringLimit = ConstU32<64>;
+	type KeyLimit = ConstU32<64>;
+	type ValueLimit = ConstU32<128>;
+	type Locker = ();
+	type WeightInfo = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type Helper = ();
+}
+
+impl shared::Config for Runtime {
+	type DisabledValidators = ();
+}
+
+impl configuration::Config for Runtime {
+	type WeightInfo = configuration::TestWeightInfo;
+}
+
+pub type LocalOriginToLocation =
+	SignedToAccountId32<RuntimeOrigin, AccountId, constants::RelayNetwork>;
+
+impl pezpallet_xcm::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
+	type XcmRouter = XcmRouter;
+	// Anyone can execute XCM messages locally...
+	type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
+	type XcmExecuteFilter = Nothing;
+	type XcmExecutor = XcmExecutor<XcmConfig>;
+	type XcmTeleportFilter = Everything;
+	type XcmReserveTransferFilter = Everything;
+	type Weigher = weigher::Weigher;
+	type UniversalLocation = constants::UniversalLocation;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
+	type AdvertisedXcmVersion = pezpallet_xcm::CurrentXcmVersion;
+	type Currency = Balances;
+	type CurrencyMatcher = IsConcrete<constants::TokenLocation>;
+	type TrustedLockers = ();
+	type SovereignAccountOf = location_converter::LocationConverter;
+	type MaxLockers = ConstU32<8>;
+	type MaxRemoteLockConsumers = ConstU32<0>;
+	type RemoteLockConsumerIdentifier = ();
+	type WeightInfo = pezpallet_xcm::TestWeightInfo;
+	type AdminOrigin = EnsureRoot<AccountId>;
+	type AuthorizedAliasConsideration = Disabled;
+}
+
+impl origin::Config for Runtime {}
+
+type Block = pezframe_system::mocking::MockBlock<Runtime>;
+
+parameter_types! {
+	/// Amount of weight that can be spent per block to service messages.
+	pub MessageQueueServiceWeight: Weight = Weight::from_parts(1_000_000_000, 1_000_000);
+	pub const MessageQueueHeapSize: u32 = 65_536;
+	pub const MessageQueueMaxStale: u32 = 16;
+}
+
+/// Message processor to handle any messages that were enqueued into the `MessageQueue` pallet.
+pub struct MessageProcessor;
+impl ProcessMessage for MessageProcessor {
+	type Origin = AggregateMessageOrigin;
+
+	fn process_message(
+		message: &[u8],
+		origin: Self::Origin,
+		meter: &mut WeightMeter,
+		id: &mut [u8; 32],
+	) -> Result<bool, ProcessMessageError> {
+		let para = match origin {
+			AggregateMessageOrigin::Ump(UmpQueueId::Para(para)) => para,
+		};
+		xcm_builder::ProcessXcmMessage::<
+			Junction,
+			xcm_executor::XcmExecutor<XcmConfig>,
+			RuntimeCall,
+		>::process_message(message, Junction::Teyrchain(para.into()), meter, id)
+	}
+}
+
+impl pezpallet_message_queue::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Size = u32;
+	type HeapSize = MessageQueueHeapSize;
+	type MaxStale = MessageQueueMaxStale;
+	type ServiceWeight = MessageQueueServiceWeight;
+	type IdleMaxServiceWeight = ();
+	type MessageProcessor = MessageProcessor;
+	type QueueChangeHandler = ();
+	type QueuePausedQuery = ();
+	type WeightInfo = ();
+}
+
+construct_runtime!(
+	pub enum Runtime
+	{
+		System: pezframe_system,
+		Balances: pezpallet_balances,
+		ParasOrigin: origin,
+		XcmPallet: pezpallet_xcm,
+		Uniques: pezpallet_uniques,
+		MessageQueue: pezpallet_message_queue,
+	}
+);

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/asset_transactor.rs

@@ -0,0 +1,38 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::relay_chain::{
+	constants::TokenLocation, location_converter::LocationConverter, AccountId, Balances, Uniques,
+};
+use xcm_builder::{
+	AsPrefixedGeneralIndex, ConvertedConcreteId, FungibleAdapter, IsConcrete, NoChecking,
+	NonFungiblesAdapter,
+};
+use xcm_executor::traits::JustTry;
+
+type LocalAssetTransactor = (
+	FungibleAdapter<Balances, IsConcrete<TokenLocation>, LocationConverter, AccountId, ()>,
+	NonFungiblesAdapter<
+		Uniques,
+		ConvertedConcreteId<u32, u32, AsPrefixedGeneralIndex<(), u32, JustTry>, JustTry>,
+		LocationConverter,
+		AccountId,
+		NoChecking,
+		(),
+	>,
+);
+
+pub type AssetTransactor = LocalAssetTransactor;

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/barrier.rs

@@ -0,0 +1,20 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use pezframe_support::traits::Everything;
+use xcm_builder::AllowUnpaidExecutionFrom;
+
+pub type Barrier = AllowUnpaidExecutionFrom<Everything>;

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/constants.rs

@@ -0,0 +1,31 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use pezframe_support::parameter_types;
+use xcm::latest::prelude::*;
+
+parameter_types! {
+	pub TokensPerSecondPerByte: (AssetId, u128, u128) =
+		(AssetId(TokenLocation::get()), 1_000_000_000_000, 1024 * 1024);
+	pub const MaxAssetsIntoHolding: u32 = 64;
+}
+
+parameter_types! {
+	pub const TokenLocation: Location = Here.into_location();
+	pub RelayNetwork: NetworkId = ByGenesis([0; 32]);
+	pub UniversalLocation: InteriorLocation = RelayNetwork::get().into();
+	pub UnitWeightCost: u64 = 1_000;
+}

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/location_converter.rs

@@ -0,0 +1,25 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::relay_chain::{constants::RelayNetwork, AccountId};
+use xcm_builder::{AccountId32Aliases, DescribeAllTerminal, DescribeFamily, HashedDescription};
+
+type LocationToAccountId = (
+	HashedDescription<AccountId, DescribeFamily<DescribeAllTerminal>>,
+	AccountId32Aliases<RelayNetwork, AccountId>,
+);
+
+pub type LocationConverter = LocationToAccountId;

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/mod.rs

@@ -0,0 +1,65 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+pub mod asset_transactor;
+pub mod barrier;
+pub mod constants;
+pub mod location_converter;
+pub mod origin_converter;
+pub mod teleporter;
+pub mod weigher;
+
+use crate::relay_chain::{RuntimeCall, XcmPallet};
+use pezframe_support::traits::{Everything, Nothing};
+use xcm_builder::{EnsureDecodableXcm, FixedRateOfFungible, FrameTransactionalProcessor};
+use xcm_executor::Config;
+
+// Generated from `decl_test_network!`
+pub type XcmRouter = EnsureDecodableXcm<crate::RelayChainXcmRouter>;
+
+pub struct XcmConfig;
+impl Config for XcmConfig {
+	type RuntimeCall = RuntimeCall;
+	type XcmSender = XcmRouter;
+	type XcmEventEmitter = ();
+	type AssetTransactor = asset_transactor::AssetTransactor;
+	type OriginConverter = origin_converter::OriginConverter;
+	type IsReserve = ();
+	type IsTeleporter = teleporter::TrustedTeleporters;
+	type UniversalLocation = constants::UniversalLocation;
+	type Barrier = barrier::Barrier;
+	type Weigher = weigher::Weigher;
+	type Trader = FixedRateOfFungible<constants::TokensPerSecondPerByte, ()>;
+	type ResponseHandler = ();
+	type AssetTrap = ();
+	type AssetLocker = XcmPallet;
+	type AssetExchanger = ();
+	type AssetClaims = ();
+	type SubscriptionService = ();
+	type PalletInstancesInfo = ();
+	type FeeManager = ();
+	type MaxAssetsIntoHolding = constants::MaxAssetsIntoHolding;
+	type MessageExporter = ();
+	type UniversalAliases = Nothing;
+	type CallDispatcher = RuntimeCall;
+	type SafeCallFilter = Everything;
+	type Aliasers = Nothing;
+	type TransactionalProcessor = FrameTransactionalProcessor;
+	type HrmpNewChannelOpenRequestHandler = ();
+	type HrmpChannelAcceptedHandler = ();
+	type HrmpChannelClosingHandler = ();
+	type XcmRecorder = XcmPallet;
+}

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/origin_converter.rs

@@ -0,0 +1,34 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::relay_chain::{
+	constants::RelayNetwork, location_converter::LocationConverter, RuntimeOrigin,
+};
+use pezkuwi_runtime_teyrchains::origin;
+use pezkuwi_teyrchain_primitives::primitives::Id as ParaId;
+use xcm_builder::{
+	ChildSystemTeyrchainAsSuperuser, ChildTeyrchainAsNative, SignedAccountId32AsNative,
+	SovereignSignedViaLocation,
+};
+
+type LocalOriginConverter = (
+	SovereignSignedViaLocation<LocationConverter, RuntimeOrigin>,
+	ChildTeyrchainAsNative<origin::Origin, RuntimeOrigin>,
+	SignedAccountId32AsNative<RelayNetwork, RuntimeOrigin>,
+	ChildSystemTeyrchainAsSuperuser<ParaId, RuntimeOrigin>,
+);
+
+pub type OriginConverter = LocalOriginConverter;

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/teleporter.rs

@@ -0,0 +1,26 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use pezframe_support::parameter_types;
+use xcm::latest::prelude::*;
+
+parameter_types! {
+	pub NftCollectionOnRelay: AssetFilter
+		= Wild(AllOf { fun: WildNonFungible, id: AssetId(GeneralIndex(1).into()) });
+	pub NftCollectionForChild: (AssetFilter, Location)
+		= (NftCollectionOnRelay::get(), Teyrchain(1).into());
+}
+pub type TrustedTeleporters = xcm_builder::Case<NftCollectionForChild>;

pezkuwi/xcm/xcm-pez-simulator/example/src/relay_chain/xcm_config/weigher.rs

@@ -0,0 +1,27 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::relay_chain::RuntimeCall;
+use pezframe_support::parameter_types;
+use xcm::latest::prelude::*;
+use xcm_builder::FixedWeightBounds;
+
+parameter_types! {
+	pub const BaseXcmWeight: Weight = Weight::from_parts(1_000, 1_000);
+	pub const MaxInstructions: u32 = 100;
+}
+
+pub type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;

pezkuwi/xcm/xcm-pez-simulator/example/src/tests.rs

@@ -0,0 +1,579 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::*;
+
+use codec::Encode;
+use pezframe_support::{assert_ok, weights::Weight};
+use xcm::latest::QueryResponseInfo;
+use xcm_pez_simulator::{mock_message_queue::ReceivedDmp, TestExt};
+
+// Helper function for forming buy execution message
+fn buy_execution<C>(fees: impl Into<Asset>) -> Instruction<C> {
+	BuyExecution { fees: fees.into(), weight_limit: Unlimited }
+}
+
+/// Helper macro to check if a system event exists in the event list.
+///
+/// Example usage:
+/// ```ignore
+/// assert!(system_contains_event!(teyrchain, System(pezframe_system::Event::Remarked { .. })));
+/// assert!(system_contains_event!(relay_chain, XcmPallet(pezpallet_xcm::Event::Attempted { .. })));
+/// ```
+macro_rules! system_contains_event {
+    ($runtime:ident, $variant:ident($($pattern:tt)*)) => {
+        $runtime::System::events().iter().any(|e| {
+            matches!(e.event, $runtime::RuntimeEvent::$variant($($pattern)*))
+        })
+    };
+}
+
+#[test]
+fn remote_account_ids_work() {
+	child_account_account_id(1, ALICE);
+	sibling_account_account_id(1, ALICE);
+	parent_account_account_id(ALICE);
+}
+
+#[test]
+fn dmp() {
+	MockNet::reset();
+
+	let remark = teyrchain::RuntimeCall::System(
+		pezframe_system::Call::<teyrchain::Runtime>::remark_with_event { remark: vec![1, 2, 3] },
+	);
+	Relay::execute_with(|| {
+		assert_ok!(RelayChainPalletXcm::send_xcm(
+			Here,
+			Teyrchain(1),
+			Xcm(vec![Transact {
+				origin_kind: OriginKind::SovereignAccount,
+				call: remark.encode().into(),
+				fallback_max_weight: None,
+			}]),
+		));
+	});
+
+	ParaA::execute_with(|| {
+		assert!(system_contains_event!(teyrchain, System(pezframe_system::Event::Remarked { .. })));
+	});
+}
+
+#[test]
+fn ump() {
+	MockNet::reset();
+
+	let remark = relay_chain::RuntimeCall::System(
+		pezframe_system::Call::<relay_chain::Runtime>::remark_with_event { remark: vec![1, 2, 3] },
+	);
+	ParaA::execute_with(|| {
+		assert_ok!(TeyrchainPalletXcm::send_xcm(
+			Here,
+			Parent,
+			Xcm(vec![Transact {
+				origin_kind: OriginKind::SovereignAccount,
+				call: remark.encode().into(),
+				fallback_max_weight: None,
+			}]),
+		));
+	});
+
+	Relay::execute_with(|| {
+		assert!(system_contains_event!(relay_chain, System(pezframe_system::Event::Remarked { .. })));
+	});
+}
+
+#[test]
+fn xcmp() {
+	MockNet::reset();
+
+	let remark = teyrchain::RuntimeCall::System(
+		pezframe_system::Call::<teyrchain::Runtime>::remark_with_event { remark: vec![1, 2, 3] },
+	);
+	ParaA::execute_with(|| {
+		assert_ok!(TeyrchainPalletXcm::send_xcm(
+			Here,
+			(Parent, Teyrchain(2)),
+			Xcm(vec![Transact {
+				origin_kind: OriginKind::SovereignAccount,
+				call: remark.encode().into(),
+				fallback_max_weight: None,
+			}]),
+		));
+	});
+
+	ParaB::execute_with(|| {
+		assert!(system_contains_event!(teyrchain, System(pezframe_system::Event::Remarked { .. })));
+	});
+}
+
+#[test]
+fn reserve_transfer() {
+	MockNet::reset();
+
+	let withdraw_amount = 123;
+
+	Relay::execute_with(|| {
+		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(
+			relay_chain::RuntimeOrigin::signed(ALICE),
+			Box::new(Teyrchain(1).into()),
+			Box::new(AccountId32 { network: None, id: ALICE.into() }.into()),
+			Box::new((Here, withdraw_amount).into()),
+			Box::new(Here.into()),
+			Unlimited,
+		));
+		assert_eq!(
+			relay_chain::Balances::free_balance(&child_account_id(1)),
+			INITIAL_BALANCE + withdraw_amount
+		);
+		// Ensure expected events were emitted
+		let attempted_emitted =
+			system_contains_event!(relay_chain, XcmPallet(pezpallet_xcm::Event::Attempted { .. }));
+		let sent_emitted =
+			system_contains_event!(relay_chain, XcmPallet(pezpallet_xcm::Event::Sent { .. }));
+		assert!(attempted_emitted, "Expected XcmPallet::Attempted event emitted");
+		assert!(sent_emitted, "Expected XcmPallet::Sent event emitted");
+	});
+
+	ParaA::execute_with(|| {
+		// free execution, full amount received
+		assert_eq!(
+			pezpallet_balances::Pallet::<teyrchain::Runtime>::free_balance(&ALICE),
+			INITIAL_BALANCE + withdraw_amount
+		);
+	});
+}
+
+#[test]
+fn reserve_transfer_with_error() {
+	use pezsp_tracing::{
+		test_log_capture::init_log_capture,
+		tracing::{subscriber, Level},
+	};
+
+	// Reset the test network
+	MockNet::reset();
+
+	// Execute XCM Transfer and Capture Logs
+	let (log_capture, subscriber) = init_log_capture(Level::ERROR, false);
+	subscriber::with_default(subscriber, || {
+		let invalid_dest = Box::new(Teyrchain(9999).into());
+		let withdraw_amount = 123;
+
+		Relay::execute_with(|| {
+			let result = RelayChainPalletXcm::limited_reserve_transfer_assets(
+				relay_chain::RuntimeOrigin::signed(ALICE),
+				invalid_dest,
+				Box::new(AccountId32 { network: None, id: ALICE.into() }.into()),
+				Box::new((Here, withdraw_amount).into()),
+				Box::new(Here.into()),
+				Unlimited,
+			);
+
+			// Ensure an error occurred
+			assert!(result.is_err(), "Expected an error due to invalid destination");
+
+			// Assert captured logs
+			assert!(log_capture.contains("XCM validate_send failed"));
+
+			// Verify that XcmPallet::Attempted was NOT emitted (rollback happened)
+			let xcm_attempted_emitted =
+				system_contains_event!(relay_chain, XcmPallet(pezpallet_xcm::Event::Attempted { .. }));
+			assert!(
+				!xcm_attempted_emitted,
+				"Expected no XcmPallet::Attempted event due to rollback, but it was emitted"
+			);
+		});
+
+		// Ensure no balance change due to the error
+		ParaA::execute_with(|| {
+			assert_eq!(
+				pezpallet_balances::Pallet::<teyrchain::Runtime>::free_balance(&ALICE),
+				INITIAL_BALANCE
+			);
+		});
+	});
+}
+
+#[test]
+fn remote_locking_and_unlocking() {
+	MockNet::reset();
+
+	let locked_amount = 100;
+
+	ParaB::execute_with(|| {
+		let message = Xcm(vec![LockAsset {
+			asset: (Here, locked_amount).into(),
+			unlocker: Teyrchain(1).into(),
+		}]);
+		assert_ok!(TeyrchainPalletXcm::send_xcm(Here, Parent, message.clone()));
+	});
+
+	Relay::execute_with(|| {
+		use pezpallet_balances::{BalanceLock, Reasons};
+		assert_eq!(
+			relay_chain::Balances::locks(&child_account_id(2)),
+			vec![BalanceLock { id: *b"py/xcmlk", amount: locked_amount, reasons: Reasons::All }]
+		);
+	});
+
+	ParaA::execute_with(|| {
+		assert_eq!(
+			ReceivedDmp::<teyrchain::Runtime>::get(),
+			vec![Xcm(vec![NoteUnlockable {
+				owner: (Parent, Teyrchain(2)).into(),
+				asset: (Parent, locked_amount).into()
+			}])]
+		);
+	});
+
+	ParaB::execute_with(|| {
+		// Request unlocking part of the funds on the relay chain
+		let message = Xcm(vec![RequestUnlock {
+			asset: (Parent, locked_amount - 50).into(),
+			locker: Parent.into(),
+		}]);
+		assert_ok!(TeyrchainPalletXcm::send_xcm(Here, (Parent, Teyrchain(1)), message));
+	});
+
+	Relay::execute_with(|| {
+		use pezpallet_balances::{BalanceLock, Reasons};
+		// Lock is reduced
+		assert_eq!(
+			relay_chain::Balances::locks(&child_account_id(2)),
+			vec![BalanceLock {
+				id: *b"py/xcmlk",
+				amount: locked_amount - 50,
+				reasons: Reasons::All
+			}]
+		);
+	});
+}
+
+/// Scenario:
+/// A teyrchain transfers an NFT resident on the relay chain to another teyrchain account.
+///
+/// Asserts that the teyrchain accounts are updated as expected.
+#[test]
+fn withdraw_and_deposit_nft() {
+	MockNet::reset();
+
+	Relay::execute_with(|| {
+		assert_eq!(relay_chain::Uniques::owner(1, 42), Some(child_account_id(1)));
+	});
+
+	ParaA::execute_with(|| {
+		let message = Xcm(vec![TransferAsset {
+			assets: (GeneralIndex(1), 42u32).into(),
+			beneficiary: Teyrchain(2).into(),
+		}]);
+		// Send withdraw and deposit
+		assert_ok!(TeyrchainPalletXcm::send_xcm(Here, Parent, message));
+	});
+
+	Relay::execute_with(|| {
+		assert_eq!(relay_chain::Uniques::owner(1, 42), Some(child_account_id(2)));
+	});
+}
+
+/// Scenario:
+/// The relay-chain teleports an NFT to a teyrchain.
+///
+/// Asserts that the teyrchain accounts are updated as expected.
+#[test]
+fn teleport_nft() {
+	MockNet::reset();
+
+	Relay::execute_with(|| {
+		// Mint the NFT (1, 69) and give it to our "teyrchain#1 alias".
+		assert_ok!(relay_chain::Uniques::mint(
+			relay_chain::RuntimeOrigin::signed(ALICE),
+			1,
+			69,
+			child_account_account_id(1, ALICE),
+		));
+		// The teyrchain#1 alias of Alice is what must hold it on the Relay-chain for it to be
+		// withdrawable by Alice on the teyrchain.
+		assert_eq!(relay_chain::Uniques::owner(1, 69), Some(child_account_account_id(1, ALICE)));
+	});
+	ParaA::execute_with(|| {
+		assert_ok!(teyrchain::ForeignUniques::force_create(
+			teyrchain::RuntimeOrigin::root(),
+			(Parent, GeneralIndex(1)).into(),
+			ALICE,
+			false,
+		));
+		assert_eq!(
+			teyrchain::ForeignUniques::owner((Parent, GeneralIndex(1)).into(), 69u32.into()),
+			None,
+		);
+		assert_eq!(teyrchain::Balances::reserved_balance(&ALICE), 0);
+
+		// IRL Alice would probably just execute this locally on the Relay-chain, but we can't
+		// easily do that here since we only send between chains.
+		let message = Xcm(vec![
+			WithdrawAsset((GeneralIndex(1), 69u32).into()),
+			InitiateTeleport {
+				assets: AllCounted(1).into(),
+				dest: Teyrchain(1).into(),
+				xcm: Xcm(vec![DepositAsset {
+					assets: AllCounted(1).into(),
+					beneficiary: (AccountId32 { id: ALICE.into(), network: None },).into(),
+				}]),
+			},
+		]);
+		// Send teleport
+		let alice = AccountId32 { id: ALICE.into(), network: None };
+		assert_ok!(TeyrchainPalletXcm::send_xcm(alice, Parent, message));
+	});
+	ParaA::execute_with(|| {
+		assert_eq!(
+			teyrchain::ForeignUniques::owner((Parent, GeneralIndex(1)).into(), 69u32.into()),
+			Some(ALICE),
+		);
+		assert_eq!(teyrchain::Balances::reserved_balance(&ALICE), 1000);
+	});
+	Relay::execute_with(|| {
+		assert_eq!(relay_chain::Uniques::owner(1, 69), None);
+	});
+}
+
+/// Scenario:
+/// The relay-chain transfers an NFT into a teyrchain's sovereign account, who then mints a
+/// trustless-backed-derived locally.
+///
+/// Asserts that the teyrchain accounts are updated as expected.
+#[test]
+fn reserve_asset_transfer_nft() {
+	pezsp_tracing::init_for_tests();
+	MockNet::reset();
+
+	Relay::execute_with(|| {
+		assert_ok!(relay_chain::Uniques::force_create(
+			relay_chain::RuntimeOrigin::root(),
+			2,
+			ALICE,
+			false
+		));
+		assert_ok!(relay_chain::Uniques::mint(
+			relay_chain::RuntimeOrigin::signed(ALICE),
+			2,
+			69,
+			child_account_account_id(1, ALICE)
+		));
+		assert_eq!(relay_chain::Uniques::owner(2, 69), Some(child_account_account_id(1, ALICE)));
+	});
+	ParaA::execute_with(|| {
+		assert_ok!(teyrchain::ForeignUniques::force_create(
+			teyrchain::RuntimeOrigin::root(),
+			(Parent, GeneralIndex(2)).into(),
+			ALICE,
+			false,
+		));
+		assert_eq!(
+			teyrchain::ForeignUniques::owner((Parent, GeneralIndex(2)).into(), 69u32.into()),
+			None,
+		);
+		assert_eq!(teyrchain::Balances::reserved_balance(&ALICE), 0);
+
+		let message = Xcm(vec![
+			WithdrawAsset((GeneralIndex(2), 69u32).into()),
+			DepositReserveAsset {
+				assets: AllCounted(1).into(),
+				dest: Teyrchain(1).into(),
+				xcm: Xcm(vec![DepositAsset {
+					assets: AllCounted(1).into(),
+					beneficiary: (AccountId32 { id: ALICE.into(), network: None },).into(),
+				}]),
+			},
+		]);
+		// Send transfer
+		let alice = AccountId32 { id: ALICE.into(), network: None };
+		assert_ok!(TeyrchainPalletXcm::send_xcm(alice, Parent, message));
+	});
+	ParaA::execute_with(|| {
+		tracing::debug!(target: "xcm-executor", "Hello");
+		assert_eq!(
+			teyrchain::ForeignUniques::owner((Parent, GeneralIndex(2)).into(), 69u32.into()),
+			Some(ALICE),
+		);
+		assert_eq!(teyrchain::Balances::reserved_balance(&ALICE), 1000);
+	});
+
+	Relay::execute_with(|| {
+		assert_eq!(relay_chain::Uniques::owner(2, 69), Some(child_account_id(1)));
+	});
+}
+
+/// Scenario:
+/// The relay-chain creates an asset class on a teyrchain and then Alice transfers her NFT into
+/// that teyrchain's sovereign account, who then mints a trustless-backed-derivative locally.
+///
+/// Asserts that the teyrchain accounts are updated as expected.
+#[test]
+fn reserve_asset_class_create_and_reserve_transfer() {
+	MockNet::reset();
+
+	Relay::execute_with(|| {
+		assert_ok!(relay_chain::Uniques::force_create(
+			relay_chain::RuntimeOrigin::root(),
+			2,
+			ALICE,
+			false
+		));
+		assert_ok!(relay_chain::Uniques::mint(
+			relay_chain::RuntimeOrigin::signed(ALICE),
+			2,
+			69,
+			child_account_account_id(1, ALICE)
+		));
+		assert_eq!(relay_chain::Uniques::owner(2, 69), Some(child_account_account_id(1, ALICE)));
+
+		let message = Xcm(vec![Transact {
+			origin_kind: OriginKind::Xcm,
+			call: teyrchain::RuntimeCall::from(
+				pezpallet_uniques::Call::<teyrchain::Runtime>::create {
+					collection: (Parent, 2u64).into(),
+					admin: parent_account_id(),
+				},
+			)
+			.encode()
+			.into(),
+			fallback_max_weight: None,
+		}]);
+		// Send creation.
+		assert_ok!(RelayChainPalletXcm::send_xcm(Here, Teyrchain(1), message));
+	});
+	ParaA::execute_with(|| {
+		// Then transfer
+		let message = Xcm(vec![
+			WithdrawAsset((GeneralIndex(2), 69u32).into()),
+			DepositReserveAsset {
+				assets: AllCounted(1).into(),
+				dest: Teyrchain(1).into(),
+				xcm: Xcm(vec![DepositAsset {
+					assets: AllCounted(1).into(),
+					beneficiary: (AccountId32 { id: ALICE.into(), network: None },).into(),
+				}]),
+			},
+		]);
+		let alice = AccountId32 { id: ALICE.into(), network: None };
+		assert_ok!(TeyrchainPalletXcm::send_xcm(alice, Parent, message));
+	});
+	ParaA::execute_with(|| {
+		assert_eq!(teyrchain::Balances::reserved_balance(&parent_account_id()), 1000);
+		assert_eq!(
+			teyrchain::ForeignUniques::collection_owner((Parent, 2u64).into()),
+			Some(parent_account_id())
+		);
+	});
+}
+
+/// Scenario:
+/// A teyrchain transfers funds on the relay chain to another teyrchain account.
+///
+/// Asserts that the teyrchain accounts are updated as expected.
+#[test]
+fn withdraw_and_deposit() {
+	MockNet::reset();
+
+	let send_amount = 10;
+
+	ParaA::execute_with(|| {
+		let message = Xcm(vec![
+			WithdrawAsset((Here, send_amount).into()),
+			buy_execution((Here, send_amount)),
+			DepositAsset { assets: AllCounted(1).into(), beneficiary: Teyrchain(2).into() },
+		]);
+		// Send withdraw and deposit
+		assert_ok!(TeyrchainPalletXcm::send_xcm(Here, Parent, message.clone()));
+	});
+
+	Relay::execute_with(|| {
+		assert_eq!(
+			relay_chain::Balances::free_balance(child_account_id(1)),
+			INITIAL_BALANCE - send_amount
+		);
+		assert_eq!(
+			relay_chain::Balances::free_balance(child_account_id(2)),
+			INITIAL_BALANCE + send_amount
+		);
+	});
+}
+
+/// Scenario:
+/// A teyrchain wants to be notified that a transfer worked correctly.
+/// It sends a `QueryHolding` after the deposit to get notified on success.
+///
+/// Asserts that the balances are updated correctly and the expected XCM is sent.
+#[test]
+fn query_holding() {
+	MockNet::reset();
+
+	let send_amount = 10;
+	let query_id_set = 1234;
+
+	// Send a message which fully succeeds on the relay chain
+	let expected_hash = ParaA::execute_with(|| {
+		let message = Xcm(vec![
+			WithdrawAsset((Here, send_amount).into()),
+			buy_execution((Here, send_amount)),
+			DepositAsset { assets: AllCounted(1).into(), beneficiary: Teyrchain(2).into() },
+			ReportHolding {
+				response_info: QueryResponseInfo {
+					destination: Teyrchain(1).into(),
+					query_id: query_id_set,
+					max_weight: Weight::from_parts(1_000_000_000, 1024 * 1024),
+				},
+				assets: All.into(),
+			},
+		]);
+		// Send withdraw and deposit with query holding
+		assert_ok!(TeyrchainPalletXcm::send_xcm(Here, Parent, message.clone(),));
+
+		VersionedXcm::from(message).using_encoded(pezsp_core::blake2_256)
+	});
+
+	// Check that transfer was executed
+	Relay::execute_with(|| {
+		// Withdraw executed
+		assert_eq!(
+			relay_chain::Balances::free_balance(child_account_id(1)),
+			INITIAL_BALANCE - send_amount
+		);
+		// Deposit executed
+		assert_eq!(
+			relay_chain::Balances::free_balance(child_account_id(2)),
+			INITIAL_BALANCE + send_amount
+		);
+	});
+
+	// Check that QueryResponse message was received
+	ParaA::execute_with(|| {
+		assert_eq!(
+			ReceivedDmp::<teyrchain::Runtime>::get(),
+			vec![Xcm(vec![
+				QueryResponse {
+					query_id: query_id_set,
+					response: Response::Assets(Assets::new()),
+					max_weight: Weight::from_parts(1_000_000_000, 1024 * 1024),
+					querier: Some(Here.into()),
+				},
+				SetTopic(expected_hash),
+			])],
+		);
+	});
+}

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/mod.rs

@@ -0,0 +1,184 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Teyrchain runtime mock.
+
+mod xcm_config;
+pub use xcm_config::*;
+
+use core::marker::PhantomData;
+use pezframe_support::{
+	construct_runtime, derive_impl, parameter_types,
+	traits::{
+		ConstU128, ContainsPair, Disabled, EnsureOrigin, EnsureOriginWithArg, Everything, Nothing,
+	},
+	weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight},
+};
+use pezframe_system::EnsureRoot;
+use pezsp_core::ConstU32;
+use pezsp_runtime::{
+	traits::{Get, IdentityLookup},
+	AccountId32,
+};
+use xcm::latest::prelude::*;
+use xcm_builder::{EnsureXcmOrigin, SignedToAccountId32};
+use xcm_executor::{traits::ConvertLocation, XcmExecutor};
+use xcm_pez_simulator::mock_message_queue;
+
+pub type AccountId = AccountId32;
+pub type Balance = u128;
+
+parameter_types! {
+	pub const BlockHashCount: u64 = 250;
+}
+
+#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+impl pezframe_system::Config for Runtime {
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type AccountData = pezpallet_balances::AccountData<Balance>;
+}
+
+#[derive_impl(pezpallet_balances::config_preludes::TestDefaultConfig)]
+impl pezpallet_balances::Config for Runtime {
+	type Balance = Balance;
+	type ExistentialDeposit = ConstU128<1>;
+	type AccountStore = System;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub struct UniquesHelper;
+#[cfg(feature = "runtime-benchmarks")]
+impl pezpallet_uniques::BenchmarkHelper<Location, AssetInstance> for UniquesHelper {
+	fn collection(i: u16) -> Location {
+		GeneralIndex(i as u128).into()
+	}
+	fn item(i: u16) -> AssetInstance {
+		AssetInstance::Index(i as u128)
+	}
+}
+
+impl pezpallet_uniques::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = Location;
+	type ItemId = AssetInstance;
+	type Currency = Balances;
+	type CreateOrigin = ForeignCreators;
+	type ForceOrigin = pezframe_system::EnsureRoot<AccountId>;
+	type CollectionDeposit = pezframe_support::traits::ConstU128<1_000>;
+	type ItemDeposit = pezframe_support::traits::ConstU128<1_000>;
+	type MetadataDepositBase = pezframe_support::traits::ConstU128<1_000>;
+	type AttributeDepositBase = pezframe_support::traits::ConstU128<1_000>;
+	type DepositPerByte = pezframe_support::traits::ConstU128<1>;
+	type StringLimit = ConstU32<64>;
+	type KeyLimit = ConstU32<64>;
+	type ValueLimit = ConstU32<128>;
+	type Locker = ();
+	type WeightInfo = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type Helper = UniquesHelper;
+}
+
+// `EnsureOriginWithArg` impl for `CreateOrigin` which allows only XCM origins
+// which are locations containing the class location.
+pub struct ForeignCreators;
+impl EnsureOriginWithArg<RuntimeOrigin, Location> for ForeignCreators {
+	type Success = AccountId;
+
+	fn try_origin(
+		o: RuntimeOrigin,
+		a: &Location,
+	) -> core::result::Result<Self::Success, RuntimeOrigin> {
+		let origin_location = pezpallet_xcm::EnsureXcm::<Everything>::try_origin(o.clone())?;
+		if !a.starts_with(&origin_location) {
+			return Err(o);
+		}
+		xcm_config::location_converter::LocationConverter::convert_location(&origin_location)
+			.ok_or(o)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(a: &Location) -> Result<RuntimeOrigin, ()> {
+		Ok(pezpallet_xcm::Origin::Xcm(a.clone()).into())
+	}
+}
+
+parameter_types! {
+	pub const ReservedXcmpWeight: Weight = Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND.saturating_div(4), 0);
+	pub const ReservedDmpWeight: Weight = Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND.saturating_div(4), 0);
+}
+
+impl mock_message_queue::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type XcmExecutor = XcmExecutor<XcmConfig>;
+}
+
+pub type LocalOriginToLocation =
+	SignedToAccountId32<RuntimeOrigin, AccountId, constants::RelayNetwork>;
+
+pub struct TrustedLockerCase<T>(PhantomData<T>);
+impl<T: Get<(Location, AssetFilter)>> ContainsPair<Location, Asset> for TrustedLockerCase<T> {
+	fn contains(origin: &Location, asset: &Asset) -> bool {
+		let (o, a) = T::get();
+		a.matches(asset) && &o == origin
+	}
+}
+
+parameter_types! {
+	pub RelayTokenForRelay: (Location, AssetFilter) = (Parent.into(), Wild(AllOf { id: AssetId(Parent.into()), fun: WildFungible }));
+}
+
+pub type TrustedLockers = TrustedLockerCase<RelayTokenForRelay>;
+
+impl pezpallet_xcm::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type SendXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
+	type XcmRouter = XcmRouter;
+	type ExecuteXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
+	type XcmExecuteFilter = Everything;
+	type XcmExecutor = XcmExecutor<XcmConfig>;
+	type XcmTeleportFilter = Nothing;
+	type XcmReserveTransferFilter = Everything;
+	type Weigher = weigher::Weigher;
+	type UniversalLocation = constants::UniversalLocation;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
+	type AdvertisedXcmVersion = pezpallet_xcm::CurrentXcmVersion;
+	type Currency = Balances;
+	type CurrencyMatcher = ();
+	type TrustedLockers = TrustedLockers;
+	type SovereignAccountOf = location_converter::LocationConverter;
+	type MaxLockers = ConstU32<8>;
+	type MaxRemoteLockConsumers = ConstU32<0>;
+	type RemoteLockConsumerIdentifier = ();
+	type WeightInfo = pezpallet_xcm::TestWeightInfo;
+	type AdminOrigin = EnsureRoot<AccountId>;
+	type AuthorizedAliasConsideration = Disabled;
+}
+
+type Block = pezframe_system::mocking::MockBlock<Runtime>;
+
+construct_runtime!(
+	pub struct Runtime {
+		System: pezframe_system,
+		Balances: pezpallet_balances,
+		MsgQueue: mock_message_queue,
+		PezkuwiXcm: pezpallet_xcm,
+		ForeignUniques: pezpallet_uniques,
+	}
+);

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/asset_transactor.rs

@@ -0,0 +1,39 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::teyrchain::{
+	constants::KsmLocation, location_converter::LocationConverter, AccountId, Balances,
+	ForeignUniques,
+};
+use xcm::latest::prelude::*;
+use xcm_builder::{
+	ConvertedConcreteId, FungibleAdapter, IsConcrete, NoChecking, NonFungiblesAdapter,
+};
+use xcm_executor::traits::JustTry;
+
+type LocalAssetTransactor = (
+	FungibleAdapter<Balances, IsConcrete<KsmLocation>, LocationConverter, AccountId, ()>,
+	NonFungiblesAdapter<
+		ForeignUniques,
+		ConvertedConcreteId<Location, AssetInstance, JustTry, JustTry>,
+		LocationConverter,
+		AccountId,
+		NoChecking,
+		(),
+	>,
+);
+
+pub type AssetTransactor = LocalAssetTransactor;

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/barrier.rs

@@ -0,0 +1,20 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use pezframe_support::traits::Everything;
+use xcm_builder::AllowUnpaidExecutionFrom;
+
+pub type Barrier = AllowUnpaidExecutionFrom<Everything>;

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/constants.rs

@@ -0,0 +1,31 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::teyrchain::Runtime;
+use pezframe_support::parameter_types;
+use xcm::latest::prelude::*;
+use xcm_pez_simulator::mock_message_queue::TeyrchainId;
+
+parameter_types! {
+	pub KsmPerSecondPerByte: (AssetId, u128, u128) = (AssetId(Parent.into()), 1, 1);
+	pub const MaxAssetsIntoHolding: u32 = 64;
+}
+
+parameter_types! {
+	pub const KsmLocation: Location = Location::parent();
+	pub const RelayNetwork: NetworkId = NetworkId::Kusama;
+	pub UniversalLocation: InteriorLocation = [GlobalConsensus(RelayNetwork::get()), Teyrchain(TeyrchainId::<Runtime>::get().into())].into();
+}

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/location_converter.rs

@@ -0,0 +1,25 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::teyrchain::{constants::RelayNetwork, AccountId};
+use xcm_builder::{AccountId32Aliases, DescribeAllTerminal, DescribeFamily, HashedDescription};
+
+type LocationToAccountId = (
+	HashedDescription<AccountId, DescribeFamily<DescribeAllTerminal>>,
+	AccountId32Aliases<RelayNetwork, AccountId>,
+);
+
+pub type LocationConverter = LocationToAccountId;

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/mod.rs

@@ -0,0 +1,65 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+pub mod asset_transactor;
+pub mod barrier;
+pub mod constants;
+pub mod location_converter;
+pub mod origin_converter;
+pub mod reserve;
+pub mod teleporter;
+pub mod weigher;
+
+use crate::teyrchain::{MsgQueue, PezkuwiXcm, RuntimeCall};
+use pezframe_support::traits::{Everything, Nothing};
+use xcm_builder::{EnsureDecodableXcm, FixedRateOfFungible, FrameTransactionalProcessor};
+
+// Generated from `decl_test_network!`
+pub type XcmRouter = EnsureDecodableXcm<crate::TeyrchainXcmRouter<MsgQueue>>;
+
+pub struct XcmConfig;
+impl xcm_executor::Config for XcmConfig {
+	type RuntimeCall = RuntimeCall;
+	type XcmSender = XcmRouter;
+	type XcmEventEmitter = PezkuwiXcm;
+	type AssetTransactor = asset_transactor::AssetTransactor;
+	type OriginConverter = origin_converter::OriginConverter;
+	type IsReserve = reserve::TrustedReserves;
+	type IsTeleporter = teleporter::TrustedTeleporters;
+	type UniversalLocation = constants::UniversalLocation;
+	type Barrier = barrier::Barrier;
+	type Weigher = weigher::Weigher;
+	type Trader = FixedRateOfFungible<constants::KsmPerSecondPerByte, ()>;
+	type ResponseHandler = ();
+	type AssetTrap = ();
+	type AssetLocker = PezkuwiXcm;
+	type AssetExchanger = ();
+	type AssetClaims = ();
+	type SubscriptionService = ();
+	type PalletInstancesInfo = ();
+	type FeeManager = ();
+	type MaxAssetsIntoHolding = constants::MaxAssetsIntoHolding;
+	type MessageExporter = ();
+	type UniversalAliases = Nothing;
+	type CallDispatcher = RuntimeCall;
+	type SafeCallFilter = Everything;
+	type Aliasers = Nothing;
+	type TransactionalProcessor = FrameTransactionalProcessor;
+	type HrmpNewChannelOpenRequestHandler = ();
+	type HrmpChannelAcceptedHandler = ();
+	type HrmpChannelClosingHandler = ();
+	type XcmRecorder = PezkuwiXcm;
+}

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/origin_converter.rs

@@ -0,0 +1,29 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::teyrchain::{
+	constants::RelayNetwork, location_converter::LocationConverter, RuntimeOrigin,
+};
+use pezpallet_xcm::XcmPassthrough;
+use xcm_builder::{SignedAccountId32AsNative, SovereignSignedViaLocation};
+
+type XcmOriginToCallOrigin = (
+	SovereignSignedViaLocation<LocationConverter, RuntimeOrigin>,
+	SignedAccountId32AsNative<RelayNetwork, RuntimeOrigin>,
+	XcmPassthrough<RuntimeOrigin>,
+);
+
+pub type OriginConverter = XcmOriginToCallOrigin;

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/reserve.rs

@@ -0,0 +1,21 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::teyrchain::teleporter::TrustedTeleporters;
+use pezframe_support::traits::EverythingBut;
+use xcm_builder::NativeAsset;
+
+pub type TrustedReserves = (NativeAsset, EverythingBut<TrustedTeleporters>);

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/teleporter.rs

@@ -0,0 +1,27 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use pezframe_support::parameter_types;
+use xcm::latest::prelude::*;
+
+parameter_types! {
+	pub NftCollectionOne: AssetFilter
+		= Wild(AllOf { fun: WildNonFungible, id: AssetId((Parent, GeneralIndex(1)).into()) });
+	pub NftCollectionOneForRelay: (AssetFilter, Location)
+		= (NftCollectionOne::get(), (Parent,).into());
+}
+
+pub type TrustedTeleporters = xcm_builder::Case<NftCollectionOneForRelay>;

pezkuwi/xcm/xcm-pez-simulator/example/src/teyrchain/xcm_config/weigher.rs

@@ -0,0 +1,27 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::teyrchain::RuntimeCall;
+use pezframe_support::parameter_types;
+use xcm::latest::prelude::*;
+use xcm_builder::FixedWeightBounds;
+
+parameter_types! {
+	pub const UnitWeightCost: Weight = Weight::from_parts(1, 1);
+	pub const MaxInstructions: u32 = 100;
+}
+
+pub type Weigher = FixedWeightBounds<UnitWeightCost, RuntimeCall, MaxInstructions>;