XCM v3 (#4097)

* cargo fmt * Create benchmarks for XCM instructions introduced in v3 (#4564) * Create benchmarks for BurnAsset and ExpectAsset * Add benchmarks for ExpectOrigin and ExpectError * Add benchmarks for QueryPallet and ExpectPallet * Add benchmarks for ReportTransactStatus and ClearTransactStatus * cargo fmt * Use AllPalletsWithSystem in mocks * Update XCM generic benchmarks for westend * Remove default impls for some XCM weight functions * Fix compilation error * Add weight_args helper attribute * Remove manually written XcmWeightInfo * Parse trailing comma * Revert "Add weight_args helper attribute" This reverts commit 3b7c47a6182e1b9227036c38b406d494c3fcf6fd. * Fixes * Fixes * XCM v3: Introduce querier field into `QueryReponse` (#4732) * Introduce querier field into QueryReponse * Convert &Option<MultiLocation> to Option<&MultiLocation> &Option<T> is almost always never quite useful, most of the time it still gets converted to an Option<&T> via `as_ref`, so we should simply make functions that accept Option<&T> instead. * Fix tests * cargo fmt * Fix benchmarks * Appease spellchecker * Fix test * Fix tests * Fix test * Fix mock * Fixes * Fix tests * Add test for response queriers * Update xcm/pallet-xcm/src/lib.rs * Test for non-existence of querier Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Fixes * Fixes * Add `starts_with` function to `MultiLocation` and `Junctions` (#4835) * add matches_prefix function to MultiLocation and Junctions * rename matches_prefix to starts_with * remove unnecessary main in doc comment Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Make use of starts_with in match_and_split Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * XCM v3: Bridge infrastructure (#4681) * XCM bridge infrastructure * Missing bit of cherry-pick * Revamped XCM proc macros; new NetworkIds * Fixes * Formatting * ExportMessage instruction and config type * Add MessageExporter definitions * Formatting * Missing files * Fixes * Initial bridging config API * Allow for two-stage XCM execution * Update xcm/src/v3/mod.rs Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * XCM crate building again * Initial bridging primitive * Docs * Docs * More work * More work * Merge branch 'gav-xcm-v3' into gav-xcm-v3-bridging * Make build * WithComputedOrigin and SovereignPaidRemoteExporter * Remove TODOs * Slim bridge API and tests. * Fixes * More work * First bridge test passing * Formatting * Another test * Next round of bridging tests * Repot tests * Cleanups * Paid bridging * Formatting * Tests * Spelling * Formatting * Fees and refactoring * Fixes * Formatting * Refactor SendXcm to become two-phase * Fix tests * Refactoring of SendXcm and ExportXcm complete * Formatting * Rename CannotReachDestination -> NotApplicable * Remove XCM v0 * Minor grumbles * Formatting * Formatting * Fixes * Fixes * Cleanup XCM config * Fee handling * Fixes * Formatting * Fixes * Bump Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Bump Substrate * XCM v3: `ExchangeAsset` and Remote-locking (#4945) * Asset Exchange and Locks * Make sure XCM typers impl MaxEncodedLen * Basic implementation for locks * Bump Substrate * Missing files * Use new API * Introduce instruction * Big refactor * Docs * Remove deprecated struct * Remove deprecated struct * Repot XCM builder tests * ExchangeAsset test * Exchange tests * Locking tests * Locking tests * Fixes and tests * Fixes * Formatting * Spelling * Add simulator test for remote locking * Fix tests * Bump * XCM v3: Support for non-fungibles (#4950) * NFT support and a test * New files. * Integration tests for sending NFTs * Formatting * Broken Cargo features * Use 2021 edition * Fixes * Formatting * Formatting * Update xcm/xcm-builder/src/asset_conversion.rs Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Update xcm/xcm-builder/src/nonfungibles_adapter.rs Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Update xcm/xcm-executor/src/lib.rs Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Fixes * Fixes * Fixes * Formatting * Fixes Co-authored-by: Bastian Köcher <info@kchr.de> Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * XCM v3: Context & ID hash (#4756) * send_xcm returns message hash * cargo fmt * Create topic register and instructions * Fix weights * Use tabs * Sketch out XcmContext * Fix doc test * Add the XCM context as a parameter to executor trait fns * Fixes * Add XcmContext parameter * Revert adding context as an arg to SendXcm trait methods * Revert adding context argument to ConvertOrigin trait methods * cargo fmt * Do not change the API of XcmExecutor::execute * Fixes * Fixes * Fixes * Fixes * Remove convenience method * Fixes * Fixes * cargo fmt * Fixes * Add benchmarks for XCM topic instructions * cargo run --quiet --profile=production --features=runtime-benchmarks -- benchmark --chain=westend-dev --steps=50 --repeat=20 --pallet=pallet_xcm_benchmarks::generic --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --header=./file_header.txt --template=./xcm/pallet-xcm-benchmarks/template.hbs --output=./runtime/westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs * Remove context argument on FilterAssetLocation * Fixes * Remove unused import * Fixes * Fixes * Fixes * Accept XCM hash parameter in ExecuteXcm trait methods * cargo fmt * Properly enable sp-io/std * Fixes * default-features = false * Fixes * Fixes * Fixes * Make XcmContext optional in withdraw_asset * Fixes * Fixes * Fixes * Modify tests to check for the correct XCM hash * Small refactor * cargo fmt * Check for expected hash in xcm-builder unit tests * Add doc comment for the optionality of the XCM context in withdraw_asset * Update xcm/src/v3/traits.rs * Update xcm/src/v3/traits.rs * Store XcmContext and avoid rebuilding * Use ref for XcmContext * Formatting * Fix incorrect hash CC @KiChjang * Refactor and make clear fake hashes * Fixes * Fixes * Fixes * Fix broken hashing * Docs * Fixes * Fixes * Fixes * Formatting * Fixes * Fixes * Fixes * Remove unknowable hash * Formatting * Use message hash for greater identifiability * Formatting * Fixes * Formatting Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> Co-authored-by: Parity Bot <admin@parity.io> * Fixes * Fixes * Fixes * Fixes * Formatting * Fixes * Formatting * Fixes * Fixes * Formatting * Formatting * Remove horrible names * Bump * Remove InvertLocation trait (#5092) * Remove InvertLocation trait * Remove unneeded functions * Formatting * Fixes * Remove XCMv1 (#5094) * Remove XCMv1 * Remove XCMv1 * Formatting * Fixes * Fixes * Formatting * derive serialize/deserialize for xcm primitives (#5036) * derive serialize/deserialize for xcm primitives * derive serialize/deserialize for xcm primitives * update v3 * update v2 Co-authored-by: Gav Wood <gavin@parity.io> * Update lock * Fixes * Add benchmarks for the ExchangeAsset instruction * `AliasOrigin` instruction stub (#5122) * AliasOrigin instruction stub * Fixes * Fixes * Update substrate * Fixes * Ensure same array length before using copy_from_slice * Fixes * Add benchmarks for the UniversalOrigin instruction * Remove unused import * Remove unused import * Add benchmarks for SetFeesMode instruction * Add benchmarks for asset (un)locking instructions * Leave AliasOrigin unbenchmarked * Fixes after merge * cargo fmt * Fixes * Fixes * Set TrustedReserves to None on both Kusama and Westend * Remove extraneous reserve_asset_deposited benchmark * Fix universal_origin benchmark * cargo run --quiet --profile=production --features=runtime-benchmarks -- benchmark pallet --chain=westend-dev --steps=50 --repeat=20 --pallet=pallet_xcm_benchmarks::generic --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --header=./file_header.txt --template=./xcm/pallet-xcm-benchmarks/template.hbs --output=./runtime/westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs * Don't rely on skipped benchmark functions * Fixes * cargo run --quiet --profile=production --features=runtime-benchmarks -- benchmark pallet --chain=kusama-dev --steps=50 --repeat=20 --pallet=pallet_xcm_benchmarks::generic --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --header=./file_header.txt --template=./xcm/pallet-xcm-benchmarks/template.hbs --output=./runtime/kusama/src/weights/xcm/pallet_xcm_benchmarks_generic.rs * Fix unused variables * Fixes * Spelling * Fixes * Fix codec index of VersionedXcm * Allows to customize how calls are dispatched from XCM (#5657) * CallDispatcher trait * fmt * unused import * fix test-runtime * remove JustDispatch type * fix typo in test-runtime * missing CallDispatcher * more missing CallDispatcher * Update comment `NoteAssetLocked` -> `NoteUnlockable` * Fixes * Fixes * Adjust MultiAssets weights based on new wild card variants * Fixes * Fixes * Fixes * Fixes * Fixes * Some late fixes for XCMv3 (#5237) * Maximise chances that trapped assets can be reclaimed * Do origin check as part of ExportMessage for security * Formatting * Fixes * Cleanup export XCM APIs * Formatting * Update xcm/src/v3/junctions.rs * UnpaidExecution instruction and associated barrier. * Tighten barriers (ClearOrigin/QueryResponse) * Allow only 1 ClearOrigin instruction in AllowTopLevelPaidExecutionFrom * Bi-directional teleport accounting * Revert other fix * Build fixes] * Tests build * Benchmark fixes Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Update Substrate * Re-export `pub` stuff from universal_exports.rs + removed unecessary clone (#6145) * Re-export `pub` stuff from universal_exports.rs * Removed unnecessary clone * Use 2D weights in XCM v3 (#6134) * Depend upon sp-core instead of sp-runtime * Make sp-io a dev-dependency * Use 2D weights in XCM v3 * cargo fmt * Add XCM pallet migration to runtimes * Use from_parts * cargo fmt * Fixes * cargo fmt * Remove XCMWeight import * Fixes * Fixes * Fixes * Fixes * Use translate in migration * Increase max upward message size in tests * Fix doc test * Remove most uses of from_ref_time * cargo fmt * Fixes * Fixes * Add extrinsic benchmarking to XCM pallet * cargo fmt * Fixes * Use old syntax * cargo fmt * Fixes * Remove hardcoded weights * Add XCM pallet to benchmarks * Use successful origin * Fix weird type parameter compilation issue * Fixes * ".git/.scripts/bench-bot.sh" runtime westend-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime rococo-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime kusama-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime polkadot-dev pallet_xcm * Use benchmarked XCM pallet weights * Fixes * Fixes * Use override instead of skip * Fixes * Fixes * Fixes * Fixes * ".git/.scripts/bench-bot.sh" runtime polkadot-dev pallet_xcm * Fixes * ".git/.scripts/bench-bot.sh" runtime polkadot-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime westend-dev pallet_xcm Co-authored-by: command-bot <> * Replace Weight::MAX with 100b weight units * Add test to ensure all_gte in barriers is correct * Update xcm/src/v3/junction.rs Co-authored-by: asynchronous rob <rphmeier@gmail.com> * Add more weight tests * cargo fmt * Create thread_local in XCM executor to limit recursion depth (#6304) * Create thread_local in XCM executor to limit recursion depth * Add unit test for recursion limit * Fix statefulness in tests * Remove panic * Use defer and environmental macro * Fix the implementation * Use nicer interface * Change ThisNetwork to AnyNetwork * Move recursion check up to top level * cargo fmt * Update comment Co-authored-by: Bastian Köcher <info@kchr.de> * Add upper limit on the number of overweight messages in the queue (#6298) * Add upper limit on the number of ovwerweight messages in the queue * Add newline * Introduce whitelist for Transact and limit UMP processing to 10 messages per block (#6280) * Add SafeCallFilter to XcmConfig * Limit UMP to receive 10 messages every block * Place 10 message limit on processing instead of receiving * Always increment the message_processed count whenever a message is processed * Add as_derivative to the Transact whitelist * cargo fmt * Fixes * Update xcm/xcm-builder/src/universal_exports.rs Co-authored-by: Branislav Kontur <bkontur@gmail.com> * Fixes * Fixes * Remove topic register and instead use the topic field in XcmContext * Derive some common traits for DispatchBlobError * Fixes * cargo fmt * Fixes * Fixes * Fix comments * Fixes * Introduce WithOriginFilter and apply it as the CallDispatcher for runtimes * Fixes * Appease clippy and fixes * Fixes * Fix more clippy issues * Fixes * ".git/.scripts/bench-bot.sh" runtime polkadot-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime westend-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime westend-dev pallet_xcm * Add benchmark function for ExportMessage * Fix comment * Add upper limit to DownwardMessageQueues size * Add max size check for queue in can_queue_downward_message * Fixes * Make Transact runtime call configurable * Return Weight::MAX when there is no successful send XCM origin * Update substrate * Fixes * Fixes * Remove ExportMessage benchmark * Remove assertion on Transact instruction benchmark * Make reachable destination configurable in XCM pallet benchmarks * Fixes * Fixes * Remove cfg attribute in fuzzer * Fixes * Remove cfg attribute for XCM pallet in test runtime * Fixes * Use ReachableDest where possible * Fixes * Add benchmark for UnpaidExecution * Update substrate * Ensure benchmark functions pass filters * Add runtime-benchmarks feature to fuzzer * Ensure FixedRateOfFungible accounts for proof size weights * cargo fmt * Whitelist remark_with_event when runtime-benchmarks feature is enabled * Use remark_with_event for Transact benchmarks * Fix Cargo.lock * Allow up to 3 DescendOrigin instructions before UnpaidExecution * cargo fmt * Edit code comment * Check check_origin for unpaid execution privilege * Fixes * Small nits for xcm-v3 (#6408) * Add possibility to skip benchmark for export_message * ".git/.scripts/bench-bot.sh" xcm westend-dev pallet_xcm_benchmarks::generic * Revert * ".git/.scripts/bench-bot.sh" xcm westend-dev pallet_xcm_benchmarks::generic * Add HaulBlobError to `fn haul_blob` * ".git/.scripts/bench-bot.sh" xcm westend-dev pallet_xcm_benchmarks::generic Co-authored-by: command-bot <> * Revert changes to UnpaidExecution * Change AllowUnpaidExecutionFrom to be explicit * Fix log text * cargo fmt * Add benchmarks for XCM pallet version migration (#6448) * Add benchmarks for XCM pallet version migration * cargo fmt * Fixes * Fixes * Fixes * ".git/.scripts/bench-bot.sh" runtime westend-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime kusama-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime rococo-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime polkadot-dev pallet_xcm * Fix benchmarks * Fix benchmarks * ".git/.scripts/bench-bot.sh" runtime westend-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime kusama-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime rococo-dev pallet_xcm * ".git/.scripts/bench-bot.sh" runtime polkadot-dev pallet_xcm Co-authored-by: command-bot <> * Merge remote-tracking branch 'origin/master' into gav-xcm-v3 * Fixes * Fix comments (#6470) * Specify Ethereum networks by their chain id (#6286) Co-authored-by: Squirrel <gilescope@gmail.com> * Use for Kusama * Use WithComputedOrigin for Polkadot, Rococo and Westend * Update lock * Fix warning * Update xcm/pallet-xcm/src/tests.rs Co-authored-by: Squirrel <gilescope@gmail.com> * Update runtime/parachains/src/ump/migration.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Update xcm/pallet-xcm/src/migration.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Fixes * cargo fmt * Typo * Update xcm/src/v3/mod.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Docs * Docs * Docs * Docs * Docs * Update xcm/src/v3/multiasset.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Add tests for MultiAssets::from_sorted_and_deduplicated * Fail gracefully when same instance NFTs are detected during push * Update Substrate to fix benchmarks * Apply suggestions from code review * Update runtime/kusama/src/xcm_config.rs * Rename arguments * Attempt to fix benchmark * ".git/.scripts/commands/bench/bench.sh" runtime polkadot-dev runtime_parachains::ump * Use actual weights for UMP pallet in Polkadot * ".git/.scripts/commands/bench/bench.sh" runtime kusama-dev runtime_parachains::ump * ".git/.scripts/commands/bench/bench.sh" runtime westend-dev runtime_parachains::ump * ".git/.scripts/commands/bench/bench.sh" runtime rococo-dev runtime_parachains::ump Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> Co-authored-by: Alexander Popiak <alexander.popiak@parity.io> Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> Co-authored-by: Bastian Köcher <info@kchr.de> Co-authored-by: Parity Bot <admin@parity.io> Co-authored-by: stanly-johnson <stanlyjohnson@outlook.com> Co-authored-by: nanocryk <6422796+nanocryk@users.noreply.github.com> Co-authored-by: Branislav Kontur <bkontur@gmail.com> Co-authored-by: asynchronous rob <rphmeier@gmail.com> Co-authored-by: command-bot <> Co-authored-by: Vincent Geddes <vincent.geddes@hey.com> Co-authored-by: Squirrel <gilescope@gmail.com> Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
2026-07-20 03:25:41 +00:00 · 2023-01-17 04:04:34 -03:00
parent 2952ad6f44
commit 1a1bfd2af9
155 changed files with 19234 additions and 8436 deletions
@@ -0,0 +1,58 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::Assets;
+use xcm::prelude::*;
+
+/// A service for exchanging assets.
+pub trait AssetExchange {
+	/// Handler for exchanging an asset.
+	///
+	/// - `origin`: The location attempting the exchange; this should generally not matter.
+	/// - `give`: The assets which have been removed from the caller.
+	/// - `want`: The minimum amount of assets which should be given to the caller in case any
+	///   exchange happens. If more assets are provided, then they should generally be of the
+	///   same asset class if at all possible.
+	/// - `maximal`: If `true`, then as much as possible should be exchanged.
+	///
+	/// `Ok` is returned along with the new set of assets which have been exchanged for `give`. At
+	/// least want must be in the set. Some assets originally in `give` may also be in this set. In
+	/// the case of returning an `Err`, then `give` is returned.
+	fn exchange_asset(
+		origin: Option<&MultiLocation>,
+		give: Assets,
+		want: &MultiAssets,
+		maximal: bool,
+	) -> Result<Assets, Assets>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl AssetExchange for Tuple {
+	fn exchange_asset(
+		origin: Option<&MultiLocation>,
+		give: Assets,
+		want: &MultiAssets,
+		maximal: bool,
+	) -> Result<Assets, Assets> {
+		for_tuples!( #(
+			let give = match Tuple::exchange_asset(origin, give, want, maximal) {
+				Ok(r) => return Ok(r),
+				Err(a) => a,
+			};
+		)* );
+		Err(give)
+	}
+}
@@ -0,0 +1,152 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use sp_std::convert::Infallible;
+use xcm::prelude::*;
+
+#[derive(Debug)]
+pub enum LockError {
+	NotApplicable,
+	WouldClobber,
+	BadOrigin,
+	NotLocked,
+	NotEnoughLocked,
+	Unimplemented,
+	NotTrusted,
+	BadOwner,
+	UnknownAsset,
+	AssetNotOwned,
+	NoResources,
+	UnexpectedState,
+	InUse,
+}
+
+impl From<LockError> for XcmError {
+	fn from(e: LockError) -> XcmError {
+		use LockError::*;
+		match e {
+			NotApplicable => XcmError::AssetNotFound,
+			BadOrigin => XcmError::BadOrigin,
+			WouldClobber | NotLocked | NotEnoughLocked | Unimplemented | NotTrusted |
+			BadOwner | UnknownAsset | AssetNotOwned | NoResources | UnexpectedState | InUse =>
+				XcmError::LockError,
+		}
+	}
+}
+
+pub trait Enact {
+	/// Enact a lock. This should generally be infallible if called immediately after being
+	/// received.
+	fn enact(self) -> Result<(), LockError>;
+}
+
+impl Enact for Infallible {
+	fn enact(self) -> Result<(), LockError> {
+		unreachable!()
+	}
+}
+
+/// Define a handler for notification of an asset being locked and for the unlock instruction.
+pub trait AssetLock {
+	/// `Enact` implementer for `prepare_lock`. This type may be dropped safely to avoid doing the
+	/// lock.
+	type LockTicket: Enact;
+
+	/// `Enact` implementer for `prepare_unlock`. This type may be dropped safely to avoid doing the
+	/// unlock.
+	type UnlockTicket: Enact;
+
+	/// `Enact` implementer for `prepare_reduce_unlockable`. This type may be dropped safely to avoid doing the
+	/// unlock.
+	type ReduceTicket: Enact;
+
+	/// Prepare to lock an asset. On success, a `Self::LockTicket` it returned, which can be used
+	/// to actually enact the lock.
+	///
+	/// WARNING: Don't call this with an undropped instance of `Self::LockTicket` or
+	/// `Self::UnlockTicket`.
+	fn prepare_lock(
+		unlocker: MultiLocation,
+		asset: MultiAsset,
+		owner: MultiLocation,
+	) -> Result<Self::LockTicket, LockError>;
+
+	/// Prepare to unlock an asset. On success, a `Self::UnlockTicket` it returned, which can be
+	/// used to actually enact the lock.
+	///
+	/// WARNING: Don't call this with an undropped instance of `Self::LockTicket` or
+	/// `Self::UnlockTicket`.
+	fn prepare_unlock(
+		locker: MultiLocation,
+		asset: MultiAsset,
+		owner: MultiLocation,
+	) -> Result<Self::UnlockTicket, LockError>;
+
+	/// Handler for when a location reports to us that an asset has been locked for us to unlock
+	/// at a later stage.
+	///
+	/// If there is no way to handle the lock report, then this should return an error so that the
+	/// sending chain can ensure the lock does not remain.
+	///
+	/// We should only act upon this message if we believe that the `origin` is honest.
+	fn note_unlockable(
+		locker: MultiLocation,
+		asset: MultiAsset,
+		owner: MultiLocation,
+	) -> Result<(), LockError>;
+
+	/// Handler for when an owner wishes to unlock an asset on a remote chain.
+	///
+	/// Returns a ticket which can be used to actually note the reduction in unlockable assets that
+	/// `owner` commands on `locker`.
+	///
+	/// WARNING: Don't call this with an undropped instance of `Self::ReduceTicket`.
+	fn prepare_reduce_unlockable(
+		locker: MultiLocation,
+		asset: MultiAsset,
+		owner: MultiLocation,
+	) -> Result<Self::ReduceTicket, LockError>;
+}
+
+impl AssetLock for () {
+	type LockTicket = Infallible;
+	type UnlockTicket = Infallible;
+	type ReduceTicket = Infallible;
+	fn prepare_lock(
+		_: MultiLocation,
+		_: MultiAsset,
+		_: MultiLocation,
+	) -> Result<Self::LockTicket, LockError> {
+		Err(LockError::NotApplicable)
+	}
+	fn prepare_unlock(
+		_: MultiLocation,
+		_: MultiAsset,
+		_: MultiLocation,
+	) -> Result<Self::UnlockTicket, LockError> {
+		Err(LockError::NotApplicable)
+	}
+	fn note_unlockable(_: MultiLocation, _: MultiAsset, _: MultiLocation) -> Result<(), LockError> {
+		Err(LockError::NotApplicable)
+	}
+	fn prepare_reduce_unlockable(
+		_: MultiLocation,
+		_: MultiAsset,
+		_: MultiLocation,
+	) -> Result<Self::ReduceTicket, LockError> {
+		Err(LockError::NotApplicable)
+	}
+}
@@ -14,9 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

+use frame_support::traits::{Contains, OriginTrait};
 use parity_scale_codec::{Decode, Encode};
-use sp_std::{borrow::Borrow, prelude::*, result::Result};
-use xcm::latest::{MultiLocation, OriginKind};
+use sp_runtime::{traits::Dispatchable, DispatchErrorWithPostInfo};
+use sp_std::{borrow::Borrow, marker::PhantomData, prelude::*, result::Result};
+use xcm::latest::prelude::*;

 /// Generic third-party conversion trait. Use this when you don't want to force the user to use default
 /// implementations of `From` and `Into` for the types you wish to convert between.
@@ -204,9 +206,43 @@ impl<O> ConvertOrigin<O> for Tuple {
 	}
 }

-/// Means of inverting a location: given a location which describes a `target` interpreted from the
-/// `source`, this will provide the corresponding location which describes the `source`.
-pub trait InvertLocation {
-	fn ancestry() -> MultiLocation;
-	fn invert_location(l: &MultiLocation) -> Result<MultiLocation, ()>;
+/// Defines how a call is dispatched with given origin.
+/// Allows to customize call dispatch, such as adapting the origin based on the call
+/// or modifying the call.
+pub trait CallDispatcher<Call: Dispatchable> {
+	fn dispatch(
+		call: Call,
+		origin: Call::RuntimeOrigin,
+	) -> Result<Call::PostInfo, DispatchErrorWithPostInfo<Call::PostInfo>>;
+}
+
+pub struct WithOriginFilter<Filter>(PhantomData<Filter>);
+impl<Call, Filter> CallDispatcher<Call> for WithOriginFilter<Filter>
+where
+	Call: Dispatchable,
+	Call::RuntimeOrigin: OriginTrait,
+	<<Call as Dispatchable>::RuntimeOrigin as OriginTrait>::Call: 'static,
+	Filter: Contains<<<Call as Dispatchable>::RuntimeOrigin as OriginTrait>::Call> + 'static,
+{
+	fn dispatch(
+		call: Call,
+		mut origin: <Call as Dispatchable>::RuntimeOrigin,
+	) -> Result<
+		<Call as Dispatchable>::PostInfo,
+		DispatchErrorWithPostInfo<<Call as Dispatchable>::PostInfo>,
+	> {
+		origin.add_filter(Filter::contains);
+		call.dispatch(origin)
+	}
+}
+
+// We implement it for every calls so they can dispatch themselves
+// (without any change).
+impl<Call: Dispatchable> CallDispatcher<Call> for Call {
+	fn dispatch(
+		call: Call,
+		origin: Call::RuntimeOrigin,
+	) -> Result<Call::PostInfo, DispatchErrorWithPostInfo<Call::PostInfo>> {
+		call.dispatch(origin)
+	}
 }
@@ -17,16 +17,15 @@
 use crate::Assets;
 use core::marker::PhantomData;
 use frame_support::traits::Contains;
-use sp_runtime::traits::Zero;
-use xcm::latest::{MultiAssets, MultiLocation, Weight};
+use xcm::latest::{MultiAssets, MultiLocation, Weight, XcmContext};

 /// Define a handler for when some non-empty `Assets` value should be dropped.
 pub trait DropAssets {
 	/// Handler for receiving dropped assets. Returns the weight consumed by this operation.
-	fn drop_assets(origin: &MultiLocation, assets: Assets) -> Weight;
+	fn drop_assets(origin: &MultiLocation, assets: Assets, context: &XcmContext) -> Weight;
 }
 impl DropAssets for () {
-	fn drop_assets(_origin: &MultiLocation, _assets: Assets) -> Weight {
+	fn drop_assets(_origin: &MultiLocation, _assets: Assets, _context: &XcmContext) -> Weight {
 		Weight::zero()
 	}
 }
@@ -36,9 +35,9 @@ impl DropAssets for () {
 pub struct FilterAssets<D, A>(PhantomData<(D, A)>);

 impl<D: DropAssets, A: Contains<Assets>> DropAssets for FilterAssets<D, A> {
-	fn drop_assets(origin: &MultiLocation, assets: Assets) -> Weight {
+	fn drop_assets(origin: &MultiLocation, assets: Assets, context: &XcmContext) -> Weight {
 		if A::contains(&assets) {
-			D::drop_assets(origin, assets)
+			D::drop_assets(origin, assets, context)
 		} else {
 			Weight::zero()
 		}
@@ -51,9 +50,9 @@ impl<D: DropAssets, A: Contains<Assets>> DropAssets for FilterAssets<D, A> {
 pub struct FilterOrigin<D, O>(PhantomData<(D, O)>);

 impl<D: DropAssets, O: Contains<MultiLocation>> DropAssets for FilterOrigin<D, O> {
-	fn drop_assets(origin: &MultiLocation, assets: Assets) -> Weight {
+	fn drop_assets(origin: &MultiLocation, assets: Assets, context: &XcmContext) -> Weight {
 		if O::contains(origin) {
-			D::drop_assets(origin, assets)
+			D::drop_assets(origin, assets, context)
 		} else {
 			Weight::zero()
 		}
@@ -64,14 +63,24 @@ impl<D: DropAssets, O: Contains<MultiLocation>> DropAssets for FilterOrigin<D, O
 pub trait ClaimAssets {
 	/// Claim any assets available to `origin` and return them in a single `Assets` value, together
 	/// with the weight used by this operation.
-	fn claim_assets(origin: &MultiLocation, ticket: &MultiLocation, what: &MultiAssets) -> bool;
+	fn claim_assets(
+		origin: &MultiLocation,
+		ticket: &MultiLocation,
+		what: &MultiAssets,
+		context: &XcmContext,
+	) -> bool;
 }

 #[impl_trait_for_tuples::impl_for_tuples(30)]
 impl ClaimAssets for Tuple {
-	fn claim_assets(origin: &MultiLocation, ticket: &MultiLocation, what: &MultiAssets) -> bool {
+	fn claim_assets(
+		origin: &MultiLocation,
+		ticket: &MultiLocation,
+		what: &MultiAssets,
+		context: &XcmContext,
+	) -> bool {
 		for_tuples!( #(
-			if Tuple::claim_assets(origin, ticket, what) {
+			if Tuple::claim_assets(origin, ticket, what, context) {
 				return true;
 			}
 		)* );
@@ -0,0 +1,146 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use xcm::latest::prelude::*;
+
+/// Utility for delivering a message to a system under a different (non-local) consensus with a
+/// spoofed origin. This essentially defines the behaviour of the `ExportMessage` XCM instruction.
+///
+/// This is quite different to `SendXcm`; `SendXcm` assumes that the local side's location will be
+/// preserved to be represented as the value of the Origin register in the messages execution.
+///
+/// This trait on the other hand assumes that we do not necessarily want the Origin register to
+/// contain the local (i.e. the caller chain's) location, since it will generally be exporting a
+/// message on behalf of another consensus system. Therefore in addition to the message, the
+/// destination must be given in two parts: the network and the interior location within it.
+///
+/// We also require the caller to state exactly what location they purport to be representing. The
+/// destination must accept the local location to represent that location or the operation will
+/// fail.
+pub trait ExportXcm {
+	/// Intermediate value which connects the two phaases of the export operation.
+	type Ticket;
+
+	/// Check whether the given `message` is deliverable to the given `destination` on `network`,
+	/// spoofing its source as `universal_source` and if so determine the cost which will be paid by
+	/// this chain to do so, returning a `Ticket` token which can be used to enact delivery.
+	///
+	/// The `channel` to be used on the `network`'s export mechanism (bridge, probably) must also
+	/// be provided.
+	///
+	/// The `destination` and `message` must be `Some` (or else an error will be returned) and they
+	/// may only be consumed if the `Err` is not `NotApplicable`.
+	///
+	/// If it is not a destination which can be reached with this type but possibly could by others,
+	/// then this *MUST* return `NotApplicable`. Any other error will cause the tuple
+	/// implementation (used to compose routing systems from different delivery agents) to exit
+	/// early without trying alternative means of delivery.
+	fn validate(
+		network: NetworkId,
+		channel: u32,
+		universal_source: &mut Option<InteriorMultiLocation>,
+		destination: &mut Option<InteriorMultiLocation>,
+		message: &mut Option<Xcm<()>>,
+	) -> SendResult<Self::Ticket>;
+
+	/// Actually carry out the delivery operation for a previously validated message sending.
+	///
+	/// The implementation should do everything possible to ensure that this function is infallible
+	/// if called immediately after `validate`. Returning an error here would result in a price
+	/// paid without the service being delivered.
+	fn deliver(ticket: Self::Ticket) -> Result<XcmHash, SendError>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl ExportXcm for Tuple {
+	for_tuples! { type Ticket = (#( Option<Tuple::Ticket> ),* ); }
+
+	fn validate(
+		network: NetworkId,
+		channel: u32,
+		universal_source: &mut Option<InteriorMultiLocation>,
+		destination: &mut Option<InteriorMultiLocation>,
+		message: &mut Option<Xcm<()>>,
+	) -> SendResult<Self::Ticket> {
+		let mut maybe_cost: Option<MultiAssets> = None;
+		let one_ticket: Self::Ticket = (for_tuples! { #(
+			if maybe_cost.is_some() {
+				None
+			} else {
+				match Tuple::validate(network, channel, universal_source, destination, message) {
+					Err(SendError::NotApplicable) => None,
+					Err(e) => { return Err(e) },
+					Ok((v, c)) => {
+						maybe_cost = Some(c);
+						Some(v)
+					},
+				}
+			}
+		),* });
+		if let Some(cost) = maybe_cost {
+			Ok((one_ticket, cost))
+		} else {
+			Err(SendError::NotApplicable)
+		}
+	}
+
+	fn deliver(one_ticket: Self::Ticket) -> Result<XcmHash, SendError> {
+		for_tuples!( #(
+			if let Some(validated) = one_ticket.Tuple.take() {
+				return Tuple::deliver(validated);
+			}
+		)* );
+		Err(SendError::Unroutable)
+	}
+}
+
+/// Convenience function for using a `SendXcm` implementation. Just interprets the `dest` and wraps
+/// both in `Some` before passing them as as mutable references into `T::send_xcm`.
+pub fn validate_export<T: ExportXcm>(
+	network: NetworkId,
+	channel: u32,
+	universal_source: InteriorMultiLocation,
+	dest: InteriorMultiLocation,
+	msg: Xcm<()>,
+) -> SendResult<T::Ticket> {
+	T::validate(network, channel, &mut Some(universal_source), &mut Some(dest), &mut Some(msg))
+}
+
+/// Convenience function for using a `SendXcm` implementation. Just interprets the `dest` and wraps
+/// both in `Some` before passing them as as mutable references into `T::send_xcm`.
+///
+/// Returns either `Ok` with the price of the delivery, or `Err` with the reason why the message
+/// could not be sent.
+///
+/// Generally you'll want to validate and get the price first to ensure that the sender can pay it
+/// before actually doing the delivery.
+pub fn export_xcm<T: ExportXcm>(
+	network: NetworkId,
+	channel: u32,
+	universal_source: InteriorMultiLocation,
+	dest: InteriorMultiLocation,
+	msg: Xcm<()>,
+) -> Result<(XcmHash, MultiAssets), SendError> {
+	let (ticket, price) = T::validate(
+		network,
+		channel,
+		&mut Some(universal_source),
+		&mut Some(dest),
+		&mut Some(msg),
+	)?;
+	let hash = T::deliver(ticket)?;
+	Ok((hash, price))
+}
@@ -0,0 +1,59 @@
+// Copyright 2022 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use xcm::prelude::*;
+
+/// Handle stuff to do with taking fees in certain XCM instructions.
+pub trait FeeManager {
+	/// Determine if a fee which would normally payable should be waived.
+	fn is_waived(origin: Option<&MultiLocation>, r: FeeReason) -> bool;
+
+	/// Do something with the fee which has been paid. Doing nothing here silently burns the
+	/// fees.
+	fn handle_fee(fee: MultiAssets);
+}
+
+/// Context under which a fee is paid.
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum FeeReason {
+	/// When a reporting instruction is called.
+	Report,
+	/// When the `TransferReserveAsset` instruction is called.
+	TransferReserveAsset,
+	/// When the `DepositReserveAsset` instruction is called.
+	DepositReserveAsset,
+	/// When the `InitiateReserveWithdraw` instruction is called.
+	InitiateReserveWithdraw,
+	/// When the `InitiateTeleport` instruction is called.
+	InitiateTeleport,
+	/// When the `QueryPallet` instruction is called.
+	QueryPallet,
+	/// When the `ExportMessage` instruction is called (and includes the network ID).
+	Export(NetworkId),
+	/// The `charge_fees` API.
+	ChargeFees,
+	/// When the `LockAsset` instruction is called.
+	LockAsset,
+	/// When the `RequestUnlock` instruction is called.
+	RequestUnlock,
+}
+
+impl FeeManager for () {
+	fn is_waived(_: Option<&MultiLocation>, _: FeeReason) -> bool {
+		true
+	}
+	fn handle_fee(_: MultiAssets) {}
+}
@@ -14,28 +14,21 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

+use frame_support::traits::ContainsPair;
 use xcm::latest::{MultiAsset, MultiLocation};

 /// Filters assets/location pairs.
 ///
 /// Can be amalgamated into tuples. If any item returns `true`, it short-circuits, else `false` is returned.
+#[deprecated = "Use `frame_support::traits::ContainsPair<MultiAsset, MultiLocation>` instead"]
 pub trait FilterAssetLocation {
 	/// A filter to distinguish between asset/location pairs.
-	fn filter_asset_location(asset: &MultiAsset, origin: &MultiLocation) -> bool;
+	fn contains(asset: &MultiAsset, origin: &MultiLocation) -> bool;
 }

-#[impl_trait_for_tuples::impl_for_tuples(30)]
-impl FilterAssetLocation for Tuple {
-	fn filter_asset_location(what: &MultiAsset, origin: &MultiLocation) -> bool {
-		for_tuples!( #(
-			if Tuple::filter_asset_location(what, origin) { return true }
-		)* );
-		log::trace!(
-			target: "xcm::filter_asset_location",
-			"got filtered: what: {:?}, origin: {:?}",
-			what,
-			origin,
-		);
-		false
+#[allow(deprecated)]
+impl<T: ContainsPair<MultiAsset, MultiLocation>> FilterAssetLocation for T {
+	fn contains(asset: &MultiAsset, origin: &MultiLocation) -> bool {
+		T::contains(asset, origin)
 	}
 }
@@ -1,32 +0,0 @@
-// Copyright 2020 Parity Technologies (UK) Ltd.
-// This file is part of Polkadot.
-
-// Polkadot 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.
-
-// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
-
-use xcm::latest::MultiAsset;
-
-pub trait MatchesFungible<Balance> {
-	fn matches_fungible(a: &MultiAsset) -> Option<Balance>;
-}
-
-#[impl_trait_for_tuples::impl_for_tuples(30)]
-impl<Balance> MatchesFungible<Balance> for Tuple {
-	fn matches_fungible(a: &MultiAsset) -> Option<Balance> {
-		for_tuples!( #(
-			match Tuple::matches_fungible(a) { o @ Some(_) => return o, _ => () }
-		)* );
-		log::trace!(target: "xcm::matches_fungible", "did not match fungible asset: {:?}", &a);
-		None
-	}
-}
@@ -17,15 +17,26 @@
 //! Various traits used in configuring the executor.

 mod conversion;
-pub use conversion::{Convert, ConvertOrigin, Decoded, Encoded, Identity, InvertLocation, JustTry};
+pub use conversion::{
+	CallDispatcher, Convert, ConvertOrigin, Decoded, Encoded, Identity, JustTry, WithOriginFilter,
+};
 mod drop_assets;
 pub use drop_assets::{ClaimAssets, DropAssets};
+mod asset_lock;
+pub use asset_lock::{AssetLock, Enact, LockError};
+mod asset_exchange;
+pub use asset_exchange::AssetExchange;
+mod export;
+pub use export::{export_xcm, validate_export, ExportXcm};
+mod fee_manager;
+pub use fee_manager::{FeeManager, FeeReason};
 mod filter_asset_location;
+#[allow(deprecated)]
 pub use filter_asset_location::FilterAssetLocation;
-mod matches_fungible;
-pub use matches_fungible::MatchesFungible;
-mod matches_fungibles;
-pub use matches_fungibles::{Error, MatchesFungibles};
+mod token_matching;
+pub use token_matching::{
+	Error, MatchesFungible, MatchesFungibles, MatchesNonFungible, MatchesNonFungibles,
+};
 mod on_response;
 pub use on_response::{OnResponse, VersionChangeNotifier};
 mod should_execute;
@@ -34,3 +45,13 @@ mod transact_asset;
 pub use transact_asset::TransactAsset;
 mod weight;
 pub use weight::{WeightBounds, WeightTrader};
+
+pub mod prelude {
+	pub use super::{
+		export_xcm, validate_export, AssetExchange, AssetLock, ClaimAssets, Convert, ConvertOrigin,
+		Decoded, DropAssets, Enact, Encoded, Error, ExportXcm, FeeManager, FeeReason, Identity,
+		JustTry, LockError, MatchesFungible, MatchesFungibles, MatchesNonFungible,
+		MatchesNonFungibles, OnResponse, ShouldExecute, TransactAsset, VersionChangeNotifier,
+		WeightBounds, WeightTrader, WithOriginFilter,
+	};
+}
@@ -14,32 +14,45 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

-use sp_runtime::traits::Zero;
 use xcm::latest::{
-	Error as XcmError, MultiLocation, QueryId, Response, Result as XcmResult, Weight,
+	Error as XcmError, MultiLocation, QueryId, Response, Result as XcmResult, Weight, XcmContext,
 };

 /// Define what needs to be done upon receiving a query response.
 pub trait OnResponse {
-	/// Returns `true` if we are expecting a response from `origin` for query `query_id`.
-	fn expecting_response(origin: &MultiLocation, query_id: u64) -> bool;
-	/// Handler for receiving a `response` from `origin` relating to `query_id`.
+	/// Returns `true` if we are expecting a response from `origin` for query `query_id` that was
+	/// queried by `querier`.
+	fn expecting_response(
+		origin: &MultiLocation,
+		query_id: u64,
+		querier: Option<&MultiLocation>,
+	) -> bool;
+	/// Handler for receiving a `response` from `origin` relating to `query_id` initiated by
+	/// `querier`.
 	fn on_response(
 		origin: &MultiLocation,
 		query_id: u64,
+		querier: Option<&MultiLocation>,
 		response: Response,
 		max_weight: Weight,
+		context: &XcmContext,
 	) -> Weight;
 }
 impl OnResponse for () {
-	fn expecting_response(_origin: &MultiLocation, _query_id: u64) -> bool {
+	fn expecting_response(
+		_origin: &MultiLocation,
+		_query_id: u64,
+		_querier: Option<&MultiLocation>,
+	) -> bool {
 		false
 	}
 	fn on_response(
 		_origin: &MultiLocation,
 		_query_id: u64,
+		_querier: Option<&MultiLocation>,
 		_response: Response,
 		_max_weight: Weight,
+		_context: &XcmContext,
 	) -> Weight {
 		Weight::zero()
 	}
@@ -50,26 +63,31 @@ pub trait VersionChangeNotifier {
 	/// Start notifying `location` should the XCM version of this chain change.
 	///
 	/// When it does, this type should ensure a `QueryResponse` message is sent with the given
-	/// `query_id` & `max_weight` and with a `response` of `Repsonse::Version`. This should happen
+	/// `query_id` & `max_weight` and with a `response` of `Response::Version`. This should happen
 	/// until/unless `stop` is called with the correct `query_id`.
 	///
 	/// If the `location` has an ongoing notification and when this function is called, then an
 	/// error should be returned.
-	fn start(location: &MultiLocation, query_id: QueryId, max_weight: u64) -> XcmResult;
+	fn start(
+		location: &MultiLocation,
+		query_id: QueryId,
+		max_weight: Weight,
+		context: &XcmContext,
+	) -> XcmResult;

 	/// Stop notifying `location` should the XCM change. Returns an error if there is no existing
 	/// notification set up.
-	fn stop(location: &MultiLocation) -> XcmResult;
+	fn stop(location: &MultiLocation, context: &XcmContext) -> XcmResult;

 	/// Return true if a location is subscribed to XCM version changes.
 	fn is_subscribed(location: &MultiLocation) -> bool;
 }

 impl VersionChangeNotifier for () {
-	fn start(_: &MultiLocation, _: QueryId, _: u64) -> XcmResult {
+	fn start(_: &MultiLocation, _: QueryId, _: Weight, _: &XcmContext) -> XcmResult {
 		Err(XcmError::Unimplemented)
 	}
-	fn stop(_: &MultiLocation) -> XcmResult {
+	fn stop(_: &MultiLocation, _: &XcmContext) -> XcmResult {
 		Err(XcmError::Unimplemented)
 	}
 	fn is_subscribed(_: &MultiLocation) -> bool {
@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

 use sp_std::result::Result;
-use xcm::latest::{MultiLocation, Weight, Xcm};
+use xcm::latest::{Instruction, MultiLocation, Weight};

 /// Trait to determine whether the execution engine should actually execute a given XCM.
 ///
@@ -25,14 +25,14 @@ pub trait ShouldExecute {
 	/// Returns `true` if the given `message` may be executed.
 	///
 	/// - `origin`: The origin (sender) of the message.
-	/// - `message`: The message itself.
+	/// - `instructions`: The message itself.
 	/// - `max_weight`: The (possibly over-) estimation of the weight of execution of the message.
 	/// - `weight_credit`: The pre-established amount of weight that the system has determined this
 	///   message may utilize in its execution. Typically non-zero only because of prior fee
 	///   payment, but could in principle be due to other factors.
 	fn should_execute<RuntimeCall>(
 		origin: &MultiLocation,
-		message: &mut Xcm<RuntimeCall>,
+		instructions: &mut [Instruction<RuntimeCall>],
 		max_weight: Weight,
 		weight_credit: &mut Weight,
 	) -> Result<(), ()>;
@@ -42,21 +42,21 @@ pub trait ShouldExecute {
 impl ShouldExecute for Tuple {
 	fn should_execute<RuntimeCall>(
 		origin: &MultiLocation,
-		message: &mut Xcm<RuntimeCall>,
+		instructions: &mut [Instruction<RuntimeCall>],
 		max_weight: Weight,
 		weight_credit: &mut Weight,
 	) -> Result<(), ()> {
 		for_tuples!( #(
-			match Tuple::should_execute(origin, message, max_weight, weight_credit) {
+			match Tuple::should_execute(origin, instructions, max_weight, weight_credit) {
 				Ok(()) => return Ok(()),
 				_ => (),
 			}
 		)* );
 		log::trace!(
 			target: "xcm::should_execute",
-			"did not pass barrier: origin: {:?}, message: {:?}, max_weight: {:?}, weight_credit: {:?}",
+			"did not pass barrier: origin: {:?}, instructions: {:?}, max_weight: {:?}, weight_credit: {:?}",
 			origin,
-			message,
+			instructions,
 			max_weight,
 			weight_credit,
 		);
@@ -15,7 +15,37 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

 use sp_std::result;
-use xcm::latest::{Error as XcmError, MultiAsset};
+use xcm::latest::prelude::*;
+
+pub trait MatchesFungible<Balance> {
+	fn matches_fungible(a: &MultiAsset) -> Option<Balance>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<Balance> MatchesFungible<Balance> for Tuple {
+	fn matches_fungible(a: &MultiAsset) -> Option<Balance> {
+		for_tuples!( #(
+			match Tuple::matches_fungible(a) { o @ Some(_) => return o, _ => () }
+		)* );
+		log::trace!(target: "xcm::matches_fungible", "did not match fungible asset: {:?}", &a);
+		None
+	}
+}
+
+pub trait MatchesNonFungible<Instance> {
+	fn matches_nonfungible(a: &MultiAsset) -> Option<Instance>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<Instance> MatchesNonFungible<Instance> for Tuple {
+	fn matches_nonfungible(a: &MultiAsset) -> Option<Instance> {
+		for_tuples!( #(
+			match Tuple::matches_nonfungible(a) { o @ Some(_) => return o, _ => () }
+		)* );
+		log::trace!(target: "xcm::matches_non_fungible", "did not match non-fungible asset: {:?}", &a);
+		None
+	}
+}

 /// Errors associated with [`MatchesFungibles`] operation.
 pub enum Error {
@@ -25,8 +55,10 @@ pub enum Error {
 	AccountIdConversionFailed,
 	/// `u128` amount to currency `Balance` conversion failed.
 	AmountToBalanceConversionFailed,
-	/// `MultiLocation` to `AssetId` conversion failed.
+	/// `MultiLocation` to `AssetId`/`ClassId` conversion failed.
 	AssetIdConversionFailed,
+	/// `AssetInstance` to non-fungibles instance ID conversion failed.
+	InstanceConversionFailed,
 }

 impl From<Error> for XcmError {
@@ -38,6 +70,7 @@ impl From<Error> for XcmError {
 			Error::AmountToBalanceConversionFailed =>
 				FailedToTransactAsset("AmountToBalanceConversionFailed"),
 			Error::AssetIdConversionFailed => FailedToTransactAsset("AssetIdConversionFailed"),
+			Error::InstanceConversionFailed => FailedToTransactAsset("InstanceConversionFailed"),
 		}
 	}
 }
@@ -47,7 +80,7 @@ pub trait MatchesFungibles<AssetId, Balance> {
 }

 #[impl_trait_for_tuples::impl_for_tuples(30)]
-impl<AssetId: Clone, Balance: Clone> MatchesFungibles<AssetId, Balance> for Tuple {
+impl<AssetId, Balance> MatchesFungibles<AssetId, Balance> for Tuple {
 	fn matches_fungibles(a: &MultiAsset) -> result::Result<(AssetId, Balance), Error> {
 		for_tuples!( #(
 			match Tuple::matches_fungibles(a) { o @ Ok(_) => return o, _ => () }
@@ -56,3 +89,18 @@ impl<AssetId: Clone, Balance: Clone> MatchesFungibles<AssetId, Balance> for Tupl
 		Err(Error::AssetNotFound)
 	}
 }
+
+pub trait MatchesNonFungibles<AssetId, Instance> {
+	fn matches_nonfungibles(a: &MultiAsset) -> result::Result<(AssetId, Instance), Error>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<AssetId, Instance> MatchesNonFungibles<AssetId, Instance> for Tuple {
+	fn matches_nonfungibles(a: &MultiAsset) -> result::Result<(AssetId, Instance), Error> {
+		for_tuples!( #(
+			match Tuple::matches_nonfungibles(a) { o @ Ok(_) => return o, _ => () }
+		)* );
+		log::trace!(target: "xcm::matches_non_fungibles", "did not match fungibles asset: {:?}", &a);
+		Err(Error::AssetNotFound)
+	}
+}
@@ -16,7 +16,7 @@

 use crate::Assets;
 use sp_std::result::Result;
-use xcm::latest::{Error as XcmError, MultiAsset, MultiLocation, Result as XcmResult};
+use xcm::latest::{Error as XcmError, MultiAsset, MultiLocation, Result as XcmResult, XcmContext};

 /// Facility for asset transacting.
 ///
@@ -26,10 +26,14 @@ use xcm::latest::{Error as XcmError, MultiAsset, MultiLocation, Result as XcmRes
 /// Can be amalgamated as a tuple of items that implement this trait. In such executions, if any of the transactors
 /// returns `Ok(())`, then it will short circuit. Else, execution is passed to the next transactor.
 pub trait TransactAsset {
-	/// Ensure that `check_in` will result in `Ok`.
+	/// Ensure that `check_in` will do as expected.
 	///
 	/// When composed as a tuple, all type-items are called and at least one must result in `Ok`.
-	fn can_check_in(_origin: &MultiLocation, _what: &MultiAsset) -> XcmResult {
+	fn can_check_in(
+		_origin: &MultiLocation,
+		_what: &MultiAsset,
+		_context: &XcmContext,
+	) -> XcmResult {
 		Err(XcmError::Unimplemented)
 	}

@@ -46,7 +50,18 @@ pub trait TransactAsset {
 	///
 	/// When composed as a tuple, all type-items are called. It is up to the implementer that there exists no
 	/// value for `_what` which can cause side-effects for more than one of the type-items.
-	fn check_in(_origin: &MultiLocation, _what: &MultiAsset) {}
+	fn check_in(_origin: &MultiLocation, _what: &MultiAsset, _context: &XcmContext) {}
+
+	/// Ensure that `check_out` will do as expected.
+	///
+	/// When composed as a tuple, all type-items are called and at least one must result in `Ok`.
+	fn can_check_out(
+		_dest: &MultiLocation,
+		_what: &MultiAsset,
+		_context: &XcmContext,
+	) -> XcmResult {
+		Err(XcmError::Unimplemented)
+	}

 	/// An asset has been teleported out to the given destination. This should do whatever housekeeping is needed.
 	///
@@ -58,20 +73,28 @@ pub trait TransactAsset {
 	///
 	/// When composed as a tuple, all type-items are called. It is up to the implementer that there exists no
 	/// value for `_what` which can cause side-effects for more than one of the type-items.
-	fn check_out(_dest: &MultiLocation, _what: &MultiAsset) {}
+	fn check_out(_dest: &MultiLocation, _what: &MultiAsset, _context: &XcmContext) {}

 	/// Deposit the `what` asset into the account of `who`.
 	///
 	/// Implementations should return `XcmError::FailedToTransactAsset` if deposit failed.
-	fn deposit_asset(_what: &MultiAsset, _who: &MultiLocation) -> XcmResult {
+	fn deposit_asset(_what: &MultiAsset, _who: &MultiLocation, _context: &XcmContext) -> XcmResult {
 		Err(XcmError::Unimplemented)
 	}

 	/// Withdraw the given asset from the consensus system. Return the actual asset(s) withdrawn,
 	/// which should always be equal to `_what`.
 	///
+	/// The XCM `_maybe_context` parameter may be `None` when the caller of `withdraw_asset` is
+	/// outside of the context of a currently-executing XCM. An example will be the `charge_fees`
+	/// method in the XCM executor.
+	///
 	/// Implementations should return `XcmError::FailedToTransactAsset` if withdraw failed.
-	fn withdraw_asset(_what: &MultiAsset, _who: &MultiLocation) -> Result<Assets, XcmError> {
+	fn withdraw_asset(
+		_what: &MultiAsset,
+		_who: &MultiLocation,
+		_maybe_context: Option<&XcmContext>,
+	) -> Result<Assets, XcmError> {
 		Err(XcmError::Unimplemented)
 	}

@@ -88,6 +111,7 @@ pub trait TransactAsset {
 		_asset: &MultiAsset,
 		_from: &MultiLocation,
 		_to: &MultiLocation,
+		_context: &XcmContext,
 	) -> Result<Assets, XcmError> {
 		Err(XcmError::Unimplemented)
 	}
@@ -100,12 +124,13 @@ pub trait TransactAsset {
 		asset: &MultiAsset,
 		from: &MultiLocation,
 		to: &MultiLocation,
+		context: &XcmContext,
 	) -> Result<Assets, XcmError> {
-		match Self::internal_transfer_asset(asset, from, to) {
-			Err(XcmError::Unimplemented) => {
-				let assets = Self::withdraw_asset(asset, from)?;
+		match Self::internal_transfer_asset(asset, from, to, context) {
+			Err(XcmError::AssetNotFound | XcmError::Unimplemented) => {
+				let assets = Self::withdraw_asset(asset, from, Some(context))?;
 				// Not a very forgiving attitude; once we implement roll-backs then it'll be nicer.
-				Self::deposit_asset(asset, to)?;
+				Self::deposit_asset(asset, to, context)?;
 				Ok(assets)
 			},
 			result => result,
@@ -115,62 +140,86 @@ pub trait TransactAsset {

 #[impl_trait_for_tuples::impl_for_tuples(30)]
 impl TransactAsset for Tuple {
-	fn can_check_in(origin: &MultiLocation, what: &MultiAsset) -> XcmResult {
+	fn can_check_in(origin: &MultiLocation, what: &MultiAsset, context: &XcmContext) -> XcmResult {
 		for_tuples!( #(
-			match Tuple::can_check_in(origin, what) {
+			match Tuple::can_check_in(origin, what, context) {
 				Err(XcmError::AssetNotFound) | Err(XcmError::Unimplemented) => (),
 				r => return r,
 			}
 		)* );
 		log::trace!(
 			target: "xcm::TransactAsset::can_check_in",
-			"asset not found: what: {:?}, origin: {:?}",
+			"asset not found: what: {:?}, origin: {:?}, context: {:?}",
 			what,
 			origin,
+			context,
 		);
 		Err(XcmError::AssetNotFound)
 	}

-	fn check_in(origin: &MultiLocation, what: &MultiAsset) {
+	fn check_in(origin: &MultiLocation, what: &MultiAsset, context: &XcmContext) {
 		for_tuples!( #(
-			Tuple::check_in(origin, what);
+			Tuple::check_in(origin, what, context);
 		)* );
 	}

-	fn check_out(dest: &MultiLocation, what: &MultiAsset) {
+	fn can_check_out(dest: &MultiLocation, what: &MultiAsset, context: &XcmContext) -> XcmResult {
 		for_tuples!( #(
-			Tuple::check_out(dest, what);
+			match Tuple::can_check_out(dest, what, context) {
+				Err(XcmError::AssetNotFound) | Err(XcmError::Unimplemented) => (),
+				r => return r,
+			}
+		)* );
+		log::trace!(
+			target: "xcm::TransactAsset::can_check_out",
+			"asset not found: what: {:?}, dest: {:?}, context: {:?}",
+			what,
+			dest,
+			context,
+		);
+		Err(XcmError::AssetNotFound)
+	}
+
+	fn check_out(dest: &MultiLocation, what: &MultiAsset, context: &XcmContext) {
+		for_tuples!( #(
+			Tuple::check_out(dest, what, context);
 		)* );
 	}

-	fn deposit_asset(what: &MultiAsset, who: &MultiLocation) -> XcmResult {
+	fn deposit_asset(what: &MultiAsset, who: &MultiLocation, context: &XcmContext) -> XcmResult {
 		for_tuples!( #(
-			match Tuple::deposit_asset(what, who) {
+			match Tuple::deposit_asset(what, who, context) {
 				Err(XcmError::AssetNotFound) | Err(XcmError::Unimplemented) => (),
 				r => return r,
 			}
 		)* );
 		log::trace!(
 			target: "xcm::TransactAsset::deposit_asset",
-			"did not deposit asset: what: {:?}, who: {:?}",
+			"did not deposit asset: what: {:?}, who: {:?}, context: {:?}",
 			what,
 			who,
+			context,
 		);
 		Err(XcmError::AssetNotFound)
 	}

-	fn withdraw_asset(what: &MultiAsset, who: &MultiLocation) -> Result<Assets, XcmError> {
+	fn withdraw_asset(
+		what: &MultiAsset,
+		who: &MultiLocation,
+		maybe_context: Option<&XcmContext>,
+	) -> Result<Assets, XcmError> {
 		for_tuples!( #(
-			match Tuple::withdraw_asset(what, who) {
+			match Tuple::withdraw_asset(what, who, maybe_context) {
 				Err(XcmError::AssetNotFound) | Err(XcmError::Unimplemented) => (),
 				r => return r,
 			}
 		)* );
 		log::trace!(
 			target: "xcm::TransactAsset::withdraw_asset",
-			"did not withdraw asset: what: {:?}, who: {:?}",
+			"did not withdraw asset: what: {:?}, who: {:?}, maybe_context: {:?}",
 			what,
 			who,
+			maybe_context,
 		);
 		Err(XcmError::AssetNotFound)
 	}
@@ -179,19 +228,21 @@ impl TransactAsset for Tuple {
 		what: &MultiAsset,
 		from: &MultiLocation,
 		to: &MultiLocation,
+		context: &XcmContext,
 	) -> Result<Assets, XcmError> {
 		for_tuples!( #(
-			match Tuple::internal_transfer_asset(what, from, to) {
+			match Tuple::internal_transfer_asset(what, from, to, context) {
 				Err(XcmError::AssetNotFound) | Err(XcmError::Unimplemented) => (),
 				r => return r,
 			}
 		)* );
 		log::trace!(
 			target: "xcm::TransactAsset::internal_transfer_asset",
-			"did not transfer asset: what: {:?}, from: {:?}, to: {:?}",
+			"did not transfer asset: what: {:?}, from: {:?}, to: {:?}, context: {:?}",
 			what,
 			from,
 			to,
+			context,
 		);
 		Err(XcmError::AssetNotFound)
 	}
@@ -207,15 +258,35 @@ mod tests {

 	pub struct NotFoundTransactor;
 	impl TransactAsset for NotFoundTransactor {
-		fn can_check_in(_origin: &MultiLocation, _what: &MultiAsset) -> XcmResult {
+		fn can_check_in(
+			_origin: &MultiLocation,
+			_what: &MultiAsset,
+			_context: &XcmContext,
+		) -> XcmResult {
 			Err(XcmError::AssetNotFound)
 		}

-		fn deposit_asset(_what: &MultiAsset, _who: &MultiLocation) -> XcmResult {
+		fn can_check_out(
+			_dest: &MultiLocation,
+			_what: &MultiAsset,
+			_context: &XcmContext,
+		) -> XcmResult {
 			Err(XcmError::AssetNotFound)
 		}

-		fn withdraw_asset(_what: &MultiAsset, _who: &MultiLocation) -> Result<Assets, XcmError> {
+		fn deposit_asset(
+			_what: &MultiAsset,
+			_who: &MultiLocation,
+			_context: &XcmContext,
+		) -> XcmResult {
+			Err(XcmError::AssetNotFound)
+		}
+
+		fn withdraw_asset(
+			_what: &MultiAsset,
+			_who: &MultiLocation,
+			_context: Option<&XcmContext>,
+		) -> Result<Assets, XcmError> {
 			Err(XcmError::AssetNotFound)
 		}

@@ -223,6 +294,7 @@ mod tests {
 			_what: &MultiAsset,
 			_from: &MultiLocation,
 			_to: &MultiLocation,
+			_context: &XcmContext,
 		) -> Result<Assets, XcmError> {
 			Err(XcmError::AssetNotFound)
 		}
@@ -230,15 +302,35 @@ mod tests {

 	pub struct OverflowTransactor;
 	impl TransactAsset for OverflowTransactor {
-		fn can_check_in(_origin: &MultiLocation, _what: &MultiAsset) -> XcmResult {
+		fn can_check_in(
+			_origin: &MultiLocation,
+			_what: &MultiAsset,
+			_context: &XcmContext,
+		) -> XcmResult {
 			Err(XcmError::Overflow)
 		}

-		fn deposit_asset(_what: &MultiAsset, _who: &MultiLocation) -> XcmResult {
+		fn can_check_out(
+			_dest: &MultiLocation,
+			_what: &MultiAsset,
+			_context: &XcmContext,
+		) -> XcmResult {
 			Err(XcmError::Overflow)
 		}

-		fn withdraw_asset(_what: &MultiAsset, _who: &MultiLocation) -> Result<Assets, XcmError> {
+		fn deposit_asset(
+			_what: &MultiAsset,
+			_who: &MultiLocation,
+			_context: &XcmContext,
+		) -> XcmResult {
+			Err(XcmError::Overflow)
+		}
+
+		fn withdraw_asset(
+			_what: &MultiAsset,
+			_who: &MultiLocation,
+			_context: Option<&XcmContext>,
+		) -> Result<Assets, XcmError> {
 			Err(XcmError::Overflow)
 		}

@@ -246,6 +338,7 @@ mod tests {
 			_what: &MultiAsset,
 			_from: &MultiLocation,
 			_to: &MultiLocation,
+			_context: &XcmContext,
 		) -> Result<Assets, XcmError> {
 			Err(XcmError::Overflow)
 		}
@@ -253,15 +346,35 @@ mod tests {

 	pub struct SuccessfulTransactor;
 	impl TransactAsset for SuccessfulTransactor {
-		fn can_check_in(_origin: &MultiLocation, _what: &MultiAsset) -> XcmResult {
+		fn can_check_in(
+			_origin: &MultiLocation,
+			_what: &MultiAsset,
+			_context: &XcmContext,
+		) -> XcmResult {
 			Ok(())
 		}

-		fn deposit_asset(_what: &MultiAsset, _who: &MultiLocation) -> XcmResult {
+		fn can_check_out(
+			_dest: &MultiLocation,
+			_what: &MultiAsset,
+			_context: &XcmContext,
+		) -> XcmResult {
 			Ok(())
 		}

-		fn withdraw_asset(_what: &MultiAsset, _who: &MultiLocation) -> Result<Assets, XcmError> {
+		fn deposit_asset(
+			_what: &MultiAsset,
+			_who: &MultiLocation,
+			_context: &XcmContext,
+		) -> XcmResult {
+			Ok(())
+		}
+
+		fn withdraw_asset(
+			_what: &MultiAsset,
+			_who: &MultiLocation,
+			_context: Option<&XcmContext>,
+		) -> Result<Assets, XcmError> {
 			Ok(Assets::default())
 		}

@@ -269,6 +382,7 @@ mod tests {
 			_what: &MultiAsset,
 			_from: &MultiLocation,
 			_to: &MultiLocation,
+			_context: &XcmContext,
 		) -> Result<Assets, XcmError> {
 			Ok(Assets::default())
 		}
@@ -280,7 +394,11 @@ mod tests {
 			(UnimplementedTransactor, NotFoundTransactor, UnimplementedTransactor);

 		assert_eq!(
-			MultiTransactor::deposit_asset(&(Here, 1).into(), &Here.into()),
+			MultiTransactor::deposit_asset(
+				&(Here, 1u128).into(),
+				&Here.into(),
+				&XcmContext::with_message_hash([0; 32]),
+			),
 			Err(XcmError::AssetNotFound)
 		);
 	}
@@ -289,7 +407,14 @@ mod tests {
 	fn unimplemented_and_not_found_continue_iteration() {
 		type MultiTransactor = (UnimplementedTransactor, NotFoundTransactor, SuccessfulTransactor);

-		assert_eq!(MultiTransactor::deposit_asset(&(Here, 1).into(), &Here.into()), Ok(()),);
+		assert_eq!(
+			MultiTransactor::deposit_asset(
+				&(Here, 1u128).into(),
+				&Here.into(),
+				&XcmContext::with_message_hash([0; 32]),
+			),
+			Ok(())
+		);
 	}

 	#[test]
@@ -297,7 +422,11 @@ mod tests {
 		type MultiTransactor = (OverflowTransactor, SuccessfulTransactor);

 		assert_eq!(
-			MultiTransactor::deposit_asset(&(Here, 1).into(), &Here.into()),
+			MultiTransactor::deposit_asset(
+				&(Here, 1u128).into(),
+				&Here.into(),
+				&XcmContext::with_message_hash([0; 32]),
+			),
 			Err(XcmError::Overflow)
 		);
 	}
@@ -306,6 +435,13 @@ mod tests {
 	fn success_stops_iteration() {
 		type MultiTransactor = (SuccessfulTransactor, OverflowTransactor);

-		assert_eq!(MultiTransactor::deposit_asset(&(Here, 1).into(), &Here.into()), Ok(()),);
+		assert_eq!(
+			MultiTransactor::deposit_asset(
+				&(Here, 1u128).into(),
+				&Here.into(),
+				&XcmContext::with_message_hash([0; 32]),
+			),
+			Ok(()),
+		);
 	}
 }