feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

pezkuwi/xcm/xcm-builder/tests/mock/mod.rs

@@ -0,0 +1,258 @@
+// 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 core::cell::RefCell;
+use frame_support::{
+	construct_runtime, derive_impl, parameter_types,
+	traits::{Disabled, Everything, Nothing},
+	weights::Weight,
+};
+use frame_system::EnsureRoot;
+use primitive_types::H256;
+use sp_runtime::{traits::IdentityLookup, AccountId32, BuildStorage};
+
+use pezkuwi_runtime_teyrchains::{configuration, origin, shared};
+use pezkuwi_teyrchain_primitives::primitives::Id as ParaId;
+use xcm::latest::{opaque, prelude::*};
+use xcm_executor::XcmExecutor;
+
+use staging_xcm_builder as xcm_builder;
+
+use xcm_builder::{
+	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom,
+	ChildSystemTeyrchainAsSuperuser, ChildTeyrchainAsNative, ChildTeyrchainConvertsVia,
+	EnsureDecodableXcm, FixedRateOfFungible, FixedWeightBounds, FungibleAdapter,
+	IsChildSystemTeyrchain, IsConcrete, MintLocation, RespectSuspension, SignedAccountId32AsNative,
+	SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
+};
+use xcm_simulator::helpers::derive_topic_id;
+
+pub type AccountId = AccountId32;
+pub type Balance = u128;
+
+thread_local! {
+	pub static SENT_XCM: RefCell<Vec<(Location, opaque::Xcm, XcmHash)>> = RefCell::new(Vec::new());
+}
+pub fn sent_xcm() -> Vec<(Location, opaque::Xcm, XcmHash)> {
+	SENT_XCM.with(|q| (*q.borrow()).clone())
+}
+pub struct TestSendXcm;
+impl SendXcm for TestSendXcm {
+	type Ticket = (Location, Xcm<()>, XcmHash);
+	fn validate(
+		dest: &mut Option<Location>,
+		msg: &mut Option<Xcm<()>>,
+	) -> SendResult<(Location, Xcm<()>, XcmHash)> {
+		let msg = msg.take().unwrap();
+		let hash = derive_topic_id(&msg);
+		let triplet = (dest.take().unwrap(), msg, hash);
+		Ok((triplet, Assets::new()))
+	}
+	fn deliver(triplet: (Location, Xcm<()>, XcmHash)) -> Result<XcmHash, SendError> {
+		let hash = triplet.2;
+		SENT_XCM.with(|q| q.borrow_mut().push(triplet));
+		Ok(hash)
+	}
+}
+
+pub type TestXcmRouter = EnsureDecodableXcm<TestSendXcm>;
+
+// copied from kusama constants
+pub const UNITS: Balance = 1_000_000_000_000;
+pub const CENTS: Balance = UNITS / 30_000;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Runtime {
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	type Hash = H256;
+	type Hashing = ::sp_runtime::traits::BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<Balance>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type DbWeight = ();
+	type BaseCallFilter = Everything;
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+parameter_types! {
+	pub ExistentialDeposit: Balance = 1 * CENTS;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Runtime {
+	type Balance = Balance;
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+	type ReserveIdentifier = [u8; 8];
+}
+
+impl shared::Config for Runtime {
+	type DisabledValidators = ();
+}
+
+impl configuration::Config for Runtime {
+	type WeightInfo = configuration::TestWeightInfo;
+}
+
+// aims to closely emulate the Kusama XcmConfig
+parameter_types! {
+	pub const KsmLocation: Location = Location::here();
+	pub const KusamaNetwork: NetworkId = NetworkId::Kusama;
+	pub UniversalLocation: InteriorLocation = KusamaNetwork::get().into();
+	pub CheckAccount: (AccountId, MintLocation) = (XcmPallet::check_account(), MintLocation::Local);
+}
+
+pub type SovereignAccountOf =
+	(ChildTeyrchainConvertsVia<ParaId, AccountId>, AccountId32Aliases<KusamaNetwork, AccountId>);
+
+pub type LocalCurrencyAdapter =
+	FungibleAdapter<Balances, IsConcrete<KsmLocation>, SovereignAccountOf, AccountId, CheckAccount>;
+
+pub type LocalAssetTransactor = (LocalCurrencyAdapter,);
+
+type LocalOriginConverter = (
+	SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
+	ChildTeyrchainAsNative<origin::Origin, RuntimeOrigin>,
+	SignedAccountId32AsNative<KusamaNetwork, RuntimeOrigin>,
+	ChildSystemTeyrchainAsSuperuser<ParaId, RuntimeOrigin>,
+);
+
+parameter_types! {
+	pub const BaseXcmWeight: Weight = Weight::from_parts(1_000_000_000, 1024);
+	pub KsmPerSecondPerByte: (AssetId, u128, u128) = (KsmLocation::get().into(), 1, 1);
+}
+
+pub type Barrier = (
+	TakeWeightCredit,
+	AllowTopLevelPaidExecutionFrom<Everything>,
+	// Unused/Untested
+	AllowUnpaidExecutionFrom<IsChildSystemTeyrchain<ParaId>>,
+);
+
+parameter_types! {
+	pub KusamaForAssetHub: (AssetFilter, Location) =
+		(Wild(AllOf { id: AssetId(Here.into()), fun: WildFungible }), Teyrchain(1000).into());
+	pub const MaxInstructions: u32 = 100;
+	pub const MaxAssetsIntoHolding: u32 = 4;
+}
+
+pub type TrustedTeleporters = (xcm_builder::Case<KusamaForAssetHub>,);
+
+pub struct XcmConfig;
+impl xcm_executor::Config for XcmConfig {
+	type RuntimeCall = RuntimeCall;
+	type XcmSender = TestXcmRouter;
+	type XcmEventEmitter = XcmPallet;
+	type AssetTransactor = LocalAssetTransactor;
+	type OriginConverter = LocalOriginConverter;
+	type IsReserve = ();
+	type IsTeleporter = TrustedTeleporters;
+	type UniversalLocation = UniversalLocation;
+	type Barrier = RespectSuspension<Barrier, XcmPallet>;
+	type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
+	type Trader = FixedRateOfFungible<KsmPerSecondPerByte, ()>;
+	type ResponseHandler = XcmPallet;
+	type AssetTrap = XcmPallet;
+	type AssetLocker = ();
+	type AssetExchanger = ();
+	type AssetClaims = XcmPallet;
+	type SubscriptionService = XcmPallet;
+	type PalletInstancesInfo = AllPalletsWithSystem;
+	type MaxAssetsIntoHolding = MaxAssetsIntoHolding;
+	type FeeManager = ();
+	type MessageExporter = ();
+	type UniversalAliases = Nothing;
+	type CallDispatcher = RuntimeCall;
+	type SafeCallFilter = Everything;
+	type Aliasers = Nothing;
+	type TransactionalProcessor = ();
+	type HrmpNewChannelOpenRequestHandler = ();
+	type HrmpChannelAcceptedHandler = ();
+	type HrmpChannelClosingHandler = ();
+	type XcmRecorder = XcmPallet;
+}
+
+/// Converts a local signed origin into an XCM location. Forms the basis for local origins
+/// sending/executing XCMs.
+pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, KusamaNetwork>;
+
+impl pallet_xcm::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type UniversalLocation = UniversalLocation;
+	type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
+	type XcmRouter = TestXcmRouter;
+	// 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 = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeOrigin = RuntimeOrigin;
+	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
+	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
+	type TrustedLockers = ();
+	type SovereignAccountOf = ();
+	type Currency = Balances;
+	type CurrencyMatcher = IsConcrete<KsmLocation>;
+	type MaxLockers = frame_support::traits::ConstU32<8>;
+	type MaxRemoteLockConsumers = frame_support::traits::ConstU32<0>;
+	type RemoteLockConsumerIdentifier = ();
+	type WeightInfo = pallet_xcm::TestWeightInfo;
+	type AdminOrigin = EnsureRoot<AccountId>;
+	// Aliasing is disabled: xcm_executor::Config::Aliasers is set to `Nothing`.
+	type AuthorizedAliasConsideration = Disabled;
+}
+
+impl origin::Config for Runtime {}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+construct_runtime!(
+	pub enum Runtime
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		ParasOrigin: origin,
+		XcmPallet: pallet_xcm,
+	}
+);
+
+pub fn kusama_like_with_balances(balances: Vec<(AccountId, Balance)>) -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+	pallet_balances::GenesisConfig::<Runtime> { balances, ..Default::default() }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}

pezkuwi/xcm/xcm-builder/tests/scenarios.rs

@@ -0,0 +1,432 @@
+// 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/>.
+
+mod mock;
+
+use mock::{
+	kusama_like_with_balances, AccountId, Balance, Balances, BaseXcmWeight, System, XcmConfig,
+	CENTS,
+};
+use pezkuwi_teyrchain_primitives::primitives::Id as ParaId;
+use sp_runtime::traits::AccountIdConversion;
+use xcm::latest::{prelude::*, Error::UntrustedTeleportLocation};
+use xcm_executor::XcmExecutor;
+use xcm_simulator::fake_message_hash;
+
+pub const ALICE: AccountId = AccountId::new([0u8; 32]);
+pub const PARA_ID: u32 = 2000;
+pub const INITIAL_BALANCE: u128 = 100_000_000_000;
+pub const REGISTER_AMOUNT: Balance = 10 * CENTS;
+
+// Construct a `BuyExecution` order.
+fn buy_execution<C>() -> Instruction<C> {
+	BuyExecution { fees: (Here, REGISTER_AMOUNT).into(), weight_limit: Unlimited }
+}
+
+/// Scenario:
+/// A teyrchain transfers funds on the relay-chain to another teyrchain's account.
+///
+/// Asserts that the teyrchain accounts are updated as expected.
+#[test]
+fn withdraw_and_deposit_works() {
+	let para_acc: AccountId = ParaId::from(PARA_ID).into_account_truncating();
+	let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
+	kusama_like_with_balances(balances).execute_with(|| {
+		let other_para_id = 3000;
+		let amount = REGISTER_AMOUNT;
+		let weight = BaseXcmWeight::get() * 3;
+		let message = Xcm(vec![
+			WithdrawAsset((Here, amount).into()),
+			buy_execution(),
+			DepositAsset {
+				assets: AllCounted(1).into(),
+				beneficiary: Teyrchain(other_para_id).into(),
+			},
+		]);
+		let mut hash = fake_message_hash(&message);
+		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
+			Teyrchain(PARA_ID),
+			message,
+			&mut hash,
+			weight,
+			Weight::zero(),
+		);
+		assert_eq!(r, Outcome::Complete { used: weight });
+		let other_para_acc: AccountId = ParaId::from(other_para_id).into_account_truncating();
+		assert_eq!(Balances::free_balance(para_acc), INITIAL_BALANCE - amount);
+		assert_eq!(Balances::free_balance(other_para_acc), amount);
+	});
+}
+
+/// Scenario:
+/// Alice simply wants to transfer funds to Bob's account via XCM.
+///
+/// Asserts that the balances are updated correctly and the correct events are fired.
+#[test]
+fn transfer_asset_works() {
+	let bob = AccountId::new([1u8; 32]);
+	let balances = vec![(ALICE, INITIAL_BALANCE), (bob.clone(), INITIAL_BALANCE)];
+	kusama_like_with_balances(balances).execute_with(|| {
+		let amount = REGISTER_AMOUNT;
+		let weight = BaseXcmWeight::get();
+		let message = Xcm(vec![TransferAsset {
+			assets: (Here, amount).into(),
+			beneficiary: AccountId32 { network: None, id: bob.clone().into() }.into(),
+		}]);
+		let mut hash = fake_message_hash(&message);
+		// Use `prepare_and_execute` here to pass through the barrier
+		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
+			AccountId32 { network: None, id: ALICE.into() },
+			message,
+			&mut hash,
+			weight,
+			weight,
+		);
+		System::assert_last_event(
+			pallet_balances::Event::Transfer { from: ALICE, to: bob.clone(), amount }.into(),
+		);
+		assert_eq!(r, Outcome::Complete { used: weight });
+		assert_eq!(Balances::free_balance(ALICE), INITIAL_BALANCE - amount);
+		assert_eq!(Balances::free_balance(bob), INITIAL_BALANCE + amount);
+	});
+}
+
+/// Scenario:
+/// A teyrchain wants to be notified that a transfer worked correctly.
+/// It includes a `QueryHolding` order after the deposit to get notified on success.
+/// This somewhat abuses `QueryHolding` as an indication of execution success. It works because
+/// order execution halts on error (so no `QueryResponse` will be sent if the previous order
+/// failed). The inner response sent due to the query is not used.
+///
+/// Asserts that the balances are updated correctly and the expected XCM is sent.
+#[test]
+fn report_holding_works() {
+	use xcm::opaque::latest::prelude::*;
+	let para_acc: AccountId = ParaId::from(PARA_ID).into_account_truncating();
+	let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
+	kusama_like_with_balances(balances).execute_with(|| {
+		let other_para_id = 3000;
+		let amount = REGISTER_AMOUNT;
+		let weight = BaseXcmWeight::get() * 4;
+		let response_info = QueryResponseInfo {
+			destination: Teyrchain(PARA_ID).into(),
+			query_id: 1234,
+			max_weight: Weight::from_parts(1_000_000_000, 1_000_000_000),
+		};
+		let message = Xcm(vec![
+			WithdrawAsset((Here, amount).into()),
+			buy_execution(),
+			DepositAsset {
+				assets: AllCounted(1).into(),
+				beneficiary: OnlyChild.into(), // invalid destination
+			},
+			// is not triggered because the deposit fails
+			ReportHolding { response_info: response_info.clone(), assets: All.into() },
+		]);
+		let mut hash = fake_message_hash(&message);
+		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
+			Teyrchain(PARA_ID),
+			message,
+			&mut hash,
+			weight,
+			Weight::zero(),
+		);
+		assert_eq!(
+			r,
+			Outcome::Incomplete {
+				used: weight - BaseXcmWeight::get(),
+				error: InstructionError {
+					index: 2,
+					error: XcmError::FailedToTransactAsset("AccountIdConversionFailed")
+				},
+			}
+		);
+		// there should be no query response sent for the failed deposit
+		assert_eq!(mock::sent_xcm(), vec![]);
+		assert_eq!(Balances::free_balance(para_acc.clone()), INITIAL_BALANCE - amount);
+
+		// now do a successful transfer
+		let message = Xcm(vec![
+			WithdrawAsset((Here, amount).into()),
+			buy_execution(),
+			DepositAsset {
+				assets: AllCounted(1).into(),
+				beneficiary: Teyrchain(other_para_id).into(),
+			},
+			// used to get a notification in case of success
+			ReportHolding { response_info: response_info.clone(), assets: AllCounted(1).into() },
+		]);
+		let mut hash = fake_message_hash(&message);
+		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
+			Teyrchain(PARA_ID),
+			message,
+			&mut hash,
+			weight,
+			Weight::zero(),
+		);
+		assert_eq!(r, Outcome::Complete { used: weight });
+		let other_para_acc: AccountId = ParaId::from(other_para_id).into_account_truncating();
+		assert_eq!(Balances::free_balance(other_para_acc), amount);
+		assert_eq!(Balances::free_balance(para_acc), INITIAL_BALANCE - 2 * amount);
+		let expected_msg = Xcm(vec![
+			QueryResponse {
+				query_id: response_info.query_id,
+				response: Response::Assets(vec![].into()),
+				max_weight: response_info.max_weight,
+				querier: Some(Here.into()),
+			},
+			SetTopic(hash.into()),
+		]);
+		assert_eq!(mock::sent_xcm(), vec![(Teyrchain(PARA_ID).into(), expected_msg, hash,)]);
+	});
+}
+
+/// Scenario:
+/// A teyrchain wants to move KSM from Kusama to Asset Hub.
+/// The teyrchain sends an XCM to withdraw funds combined with a teleport to the destination.
+///
+/// This way of moving funds from a relay to a teyrchain will only work for trusted chains.
+/// Reserve based transfer should be used to move KSM to a community teyrchain.
+///
+/// Asserts that the balances are updated accordingly and the correct XCM is sent.
+#[test]
+fn teleport_to_asset_hub_works() {
+	use xcm::opaque::latest::prelude::*;
+	let para_acc: AccountId = ParaId::from(PARA_ID).into_account_truncating();
+	let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
+	kusama_like_with_balances(balances).execute_with(|| {
+		let asset_hub_id = 1000;
+		let other_para_id = 3000;
+		let amount = REGISTER_AMOUNT;
+		let teleport_effects = vec![
+			buy_execution(), // unchecked mock value
+			DepositAsset {
+				assets: AllCounted(1).into(),
+				beneficiary: (Parent, Teyrchain(PARA_ID)).into(),
+			},
+		];
+		let weight = BaseXcmWeight::get() * 3;
+
+		// teleports are not allowed to other chains, in the absence of trust from their side
+		let message = Xcm(vec![
+			WithdrawAsset((Here, amount).into()),
+			buy_execution(),
+			InitiateTeleport {
+				assets: All.into(),
+				dest: Teyrchain(other_para_id).into(),
+				xcm: Xcm(teleport_effects.clone()),
+			},
+		]);
+		let mut hash = fake_message_hash(&message);
+		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
+			Teyrchain(PARA_ID),
+			message,
+			&mut hash,
+			weight,
+			Weight::zero(),
+		);
+		assert_eq!(
+			r,
+			Outcome::Incomplete {
+				used: weight,
+				error: InstructionError { index: 2, error: UntrustedTeleportLocation },
+			}
+		);
+
+		// teleports are allowed from asset hub to kusama.
+		let message = Xcm(vec![
+			WithdrawAsset((Here, amount).into()),
+			buy_execution(),
+			InitiateTeleport {
+				assets: All.into(),
+				dest: Teyrchain(asset_hub_id).into(),
+				xcm: Xcm(teleport_effects.clone()),
+			},
+		]);
+		let mut hash = fake_message_hash(&message);
+		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
+			Teyrchain(PARA_ID),
+			message,
+			&mut hash,
+			weight,
+			Weight::zero(),
+		);
+		assert_eq!(r, Outcome::Complete { used: weight });
+		// 2 * amount because of the other teleport above
+		assert_eq!(Balances::free_balance(para_acc), INITIAL_BALANCE - 2 * amount);
+		let expected_msg = Xcm(vec![ReceiveTeleportedAsset((Parent, amount).into()), ClearOrigin]
+			.into_iter()
+			.chain(teleport_effects.clone().into_iter())
+			.chain([SetTopic(hash.into())])
+			.collect());
+		assert_eq!(mock::sent_xcm(), vec![(Teyrchain(asset_hub_id).into(), expected_msg, hash,)]);
+	});
+}
+
+/// Scenario:
+/// A teyrchain wants to move KSM from Kusama to the teyrchain.
+/// It withdraws funds and then deposits them into the reserve account of the destination chain.
+/// to the destination.
+///
+/// Asserts that the balances are updated accordingly and the correct XCM is sent.
+#[test]
+fn reserve_based_transfer_works() {
+	use xcm::opaque::latest::prelude::*;
+	let para_acc: AccountId = ParaId::from(PARA_ID).into_account_truncating();
+	let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
+	kusama_like_with_balances(balances).execute_with(|| {
+		let other_para_id = 3000;
+		let amount = REGISTER_AMOUNT;
+		let transfer_effects = vec![
+			buy_execution(), // unchecked mock value
+			DepositAsset {
+				assets: AllCounted(1).into(),
+				beneficiary: (Parent, Teyrchain(PARA_ID)).into(),
+			},
+		];
+		let message = Xcm(vec![
+			WithdrawAsset((Here, amount).into()),
+			buy_execution(),
+			DepositReserveAsset {
+				assets: AllCounted(1).into(),
+				dest: Teyrchain(other_para_id).into(),
+				xcm: Xcm(transfer_effects.clone()),
+			},
+		]);
+		let mut hash = fake_message_hash(&message);
+		let weight = BaseXcmWeight::get() * 3;
+		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
+			Teyrchain(PARA_ID),
+			message,
+			&mut hash,
+			weight,
+			Weight::zero(),
+		);
+		assert_eq!(r, Outcome::Complete { used: weight });
+		assert_eq!(Balances::free_balance(para_acc), INITIAL_BALANCE - amount);
+		let expected_msg = Xcm(vec![ReserveAssetDeposited((Parent, amount).into()), ClearOrigin]
+			.into_iter()
+			.chain(transfer_effects.into_iter())
+			.chain([SetTopic(hash.into())])
+			.collect());
+		assert_eq!(mock::sent_xcm(), vec![(Teyrchain(other_para_id).into(), expected_msg, hash,)]);
+	});
+}
+
+/// Scenario:
+/// A recursive XCM that triggers itself via `SetAppendix`.
+/// The execution should fail due to inner filter.
+#[test]
+fn recursive_xcm_execution_fail() {
+	use crate::mock::*;
+	use frame_support::traits::{Everything, Nothing, ProcessMessageError};
+	use staging_xcm_builder::*;
+	use std::ops::ControlFlow;
+	use xcm::opaque::latest::prelude::*;
+	use xcm_executor::traits::{DenyExecution, Properties, ShouldExecute};
+
+	// Dummy filter to allow all
+	struct AllowAll;
+	impl ShouldExecute for AllowAll {
+		fn should_execute<RuntimeCall>(
+			_: &Location,
+			_: &mut [Instruction<RuntimeCall>],
+			_: Weight,
+			_: &mut Properties,
+		) -> Result<(), ProcessMessageError> {
+			Ok(())
+		}
+	}
+
+	// Dummy filter which denies `ClearOrigin`
+	struct DenyClearOrigin;
+	impl DenyExecution for DenyClearOrigin {
+		fn deny_execution<RuntimeCall>(
+			_: &Location,
+			instructions: &mut [Instruction<RuntimeCall>],
+			_: Weight,
+			_: &mut Properties,
+		) -> Result<(), ProcessMessageError> {
+			instructions.matcher().match_next_inst_while(
+				|_| true,
+				|inst| match inst {
+					ClearOrigin => Err(ProcessMessageError::Unsupported),
+					_ => Ok(ControlFlow::Continue(())),
+				},
+			)?;
+			Ok(())
+		}
+	}
+
+	struct XcmTestConfig;
+	impl xcm_executor::Config for XcmTestConfig {
+		type RuntimeCall = RuntimeCall;
+		type XcmSender = TestXcmRouter;
+		type XcmEventEmitter = ();
+		type AssetTransactor = LocalAssetTransactor;
+		type OriginConverter = ();
+		type IsReserve = ();
+		type IsTeleporter = TrustedTeleporters;
+		type UniversalLocation = UniversalLocation;
+		type Barrier = DenyThenTry<DenyRecursively<DenyClearOrigin>, AllowAll>;
+		type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
+		type Trader = FixedRateOfFungible<KsmPerSecondPerByte, ()>;
+		type ResponseHandler = XcmPallet;
+		type AssetTrap = XcmPallet;
+		type AssetLocker = ();
+		type AssetExchanger = ();
+		type AssetClaims = XcmPallet;
+		type SubscriptionService = XcmPallet;
+		type PalletInstancesInfo = AllPalletsWithSystem;
+		type MaxAssetsIntoHolding = MaxAssetsIntoHolding;
+		type FeeManager = ();
+		type MessageExporter = ();
+		type UniversalAliases = Nothing;
+		type CallDispatcher = RuntimeCall;
+		type SafeCallFilter = Everything;
+		type Aliasers = Nothing;
+		type TransactionalProcessor = ();
+		type HrmpNewChannelOpenRequestHandler = ();
+		type HrmpChannelAcceptedHandler = ();
+		type HrmpChannelClosingHandler = ();
+		type XcmRecorder = XcmPallet;
+	}
+
+	let para_acc: AccountId = ParaId::from(PARA_ID).into_account_truncating();
+	let balances = vec![(ALICE, INITIAL_BALANCE), (para_acc.clone(), INITIAL_BALANCE)];
+	let origin = Teyrchain(PARA_ID);
+	let message = Xcm(vec![SetAppendix(Xcm(vec![SetAppendix(Xcm(vec![ClearOrigin]))]))]);
+	let mut hash = fake_message_hash(&message);
+	let weight = BaseXcmWeight::get() * 3;
+
+	kusama_like_with_balances(balances).execute_with(|| {
+		let outcome = XcmExecutor::<XcmTestConfig>::prepare_and_execute(
+			origin,
+			message,
+			&mut hash,
+			weight,
+			Weight::zero(),
+		);
+
+		assert_eq!(
+			outcome,
+			Outcome::Incomplete {
+				used: Weight::from_parts(3000000000, 3072),
+				error: InstructionError { index: 0, error: XcmError::Barrier },
+			}
+		);
+	});
+}