// Copyright (C) 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/>.

//! Pallet to handle XCM messages.

#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(feature = "runtime-benchmarks")]

pub mod benchmarking;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

pub mod migration;

extern crate alloc;

use alloc::{boxed::Box, vec, vec::Vec};

use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};

use core::{marker::PhantomData, result::Result};

use frame_support::{

	dispatch::{

		DispatchErrorWithPostInfo, GetDispatchInfo, PostDispatchInfo, WithPostDispatchInfo,

	},

	pallet_prelude::*,

	traits::{

		Contains, ContainsPair, Currency, Defensive, EnsureOrigin, Get, LockableCurrency,

		OriginTrait, WithdrawReasons,

	},

	PalletId,

};

use frame_system::pallet_prelude::{BlockNumberFor, *};

pub use pallet::*;

use scale_info::TypeInfo;

use sp_runtime::{

	traits::{

		AccountIdConversion, BadOrigin, BlakeTwo256, BlockNumberProvider, Dispatchable, Hash,

		Saturating, Zero,

	},

	Either, RuntimeDebug,

};

use xcm::{latest::QueryResponseInfo, prelude::*};

use xcm_builder::{

	ExecuteController, ExecuteControllerWeightInfo, InspectMessageQueues, QueryController,

	QueryControllerWeightInfo, SendController, SendControllerWeightInfo,

};

use xcm_executor::{

	traits::{

		AssetTransferError, CheckSuspension, ClaimAssets, ConvertLocation, ConvertOrigin,

		DropAssets, MatchesFungible, OnResponse, Properties, QueryHandler, QueryResponseStatus,

		RecordXcm, TransactAsset, TransferType, VersionChangeNotifier, WeightBounds,

		XcmAssetTransfers,

	},

	AssetsInHolding,

};

use xcm_runtime_apis::{

	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},

	fees::Error as XcmPaymentApiError,

};

#[cfg(any(feature = "try-runtime", test))]

use sp_runtime::TryRuntimeError;

pub trait WeightInfo {

	fn send() -> Weight;

	fn teleport_assets() -> Weight;

	fn reserve_transfer_assets() -> Weight;

	fn transfer_assets() -> Weight;

	fn execute() -> Weight;

	fn force_xcm_version() -> Weight;

	fn force_default_xcm_version() -> Weight;

	fn force_subscribe_version_notify() -> Weight;

	fn force_unsubscribe_version_notify() -> Weight;

	fn force_suspension() -> Weight;

	fn migrate_supported_version() -> Weight;

	fn migrate_version_notifiers() -> Weight;

	fn already_notified_target() -> Weight;

	fn notify_current_targets() -> Weight;

	fn notify_target_migration_fail() -> Weight;

	fn migrate_version_notify_targets() -> Weight;

	fn migrate_and_notify_old_targets() -> Weight;

	fn new_query() -> Weight;

	fn take_response() -> Weight;

	fn claim_assets() -> Weight;

}

/// fallback implementation

pub struct TestWeightInfo;

impl WeightInfo for TestWeightInfo {

}

pub mod pallet {

	use super::*;

	use frame_support::{

		dispatch::{GetDispatchInfo, PostDispatchInfo},

		parameter_types,

	};

	use frame_system::Config as SysConfig;

	use sp_core::H256;

	use sp_runtime::traits::Dispatchable;

	use xcm_executor::traits::{MatchesFungible, WeightBounds};

	parameter_types! {

		/// An implementation of `Get<u32>` which just returns the latest XCM version which we can

		/// support.

		pub const CurrentXcmVersion: u32 = XCM_VERSION;

	}

	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);

	#[pallet::storage_version(STORAGE_VERSION)]

	pub struct Pallet<T>(_);

	pub type BalanceOf<T> =

		<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;

	#[pallet::config]

	/// The module configuration trait.

	pub trait Config: frame_system::Config {

		/// The overarching event type.

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// A lockable currency.

		// TODO: We should really use a trait which can handle multiple currencies.

		type Currency: LockableCurrency<Self::AccountId, Moment = BlockNumberFor<Self>>;

		/// The `Asset` matcher for `Currency`.

		type CurrencyMatcher: MatchesFungible<BalanceOf<Self>>;

		/// Required origin for sending XCM messages. If successful, it resolves to `Location`

		/// which exists as an interior location within this chain's XCM context.

		type SendXcmOrigin: EnsureOrigin<<Self as SysConfig>::RuntimeOrigin, Success = Location>;

		/// The type used to actually dispatch an XCM to its destination.

		type XcmRouter: SendXcm;

		/// Required origin for executing XCM messages, including the teleport functionality. If

		/// successful, then it resolves to `Location` which exists as an interior location

		/// within this chain's XCM context.

		type ExecuteXcmOrigin: EnsureOrigin<<Self as SysConfig>::RuntimeOrigin, Success = Location>;

		/// Our XCM filter which messages to be executed using `XcmExecutor` must pass.

		type XcmExecuteFilter: Contains<(Location, Xcm<<Self as Config>::RuntimeCall>)>;

		/// Something to execute an XCM message.

		type XcmExecutor: ExecuteXcm<<Self as Config>::RuntimeCall> + XcmAssetTransfers;

		/// Our XCM filter which messages to be teleported using the dedicated extrinsic must pass.

		type XcmTeleportFilter: Contains<(Location, Vec<Asset>)>;

		/// Our XCM filter which messages to be reserve-transferred using the dedicated extrinsic

		/// must pass.

		type XcmReserveTransferFilter: Contains<(Location, Vec<Asset>)>;

		/// Means of measuring the weight consumed by an XCM message locally.

		type Weigher: WeightBounds<<Self as Config>::RuntimeCall>;

		/// This chain's Universal Location.

		type UniversalLocation: Get<InteriorLocation>;

		/// The runtime `Origin` type.

		type RuntimeOrigin: From<Origin> + From<<Self as SysConfig>::RuntimeOrigin>;

		/// The runtime `Call` type.

		type RuntimeCall: Parameter

			+ GetDispatchInfo

			+ Dispatchable<

				RuntimeOrigin = <Self as Config>::RuntimeOrigin,

				PostInfo = PostDispatchInfo,

			>;

		const VERSION_DISCOVERY_QUEUE_SIZE: u32;

		/// The latest supported version that we advertise. Generally just set it to

		/// `pallet_xcm::CurrentXcmVersion`.

		type AdvertisedXcmVersion: Get<XcmVersion>;

		/// The origin that is allowed to call privileged operations on the XCM pallet

		type AdminOrigin: EnsureOrigin<<Self as SysConfig>::RuntimeOrigin>;

		/// The assets which we consider a given origin is trusted if they claim to have placed a

		/// lock.

		type TrustedLockers: ContainsPair<Location, Asset>;

		/// How to get an `AccountId` value from a `Location`, useful for handling asset locks.

		type SovereignAccountOf: ConvertLocation<Self::AccountId>;

		/// The maximum number of local XCM locks that a single account may have.

		type MaxLockers: Get<u32>;

		/// The maximum number of consumers a single remote lock may have.

		type MaxRemoteLockConsumers: Get<u32>;

		/// The ID type for local consumers of remote locks.

		type RemoteLockConsumerIdentifier: Parameter + Member + MaxEncodedLen + Ord + Copy;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

	}

	impl<T: Config> ExecuteControllerWeightInfo for Pallet<T> {

	}

	impl<T: Config> ExecuteController<OriginFor<T>, <T as Config>::RuntimeCall> for Pallet<T> {

		type WeightInfo = Self;

	}

	impl<T: Config> SendControllerWeightInfo for Pallet<T> {

	}

	impl<T: Config> SendController<OriginFor<T>> for Pallet<T> {

		type WeightInfo = Self;

	}

	impl<T: Config> QueryControllerWeightInfo for Pallet<T> {

	}

	impl<T: Config> QueryController<OriginFor<T>, BlockNumberFor<T>> for Pallet<T> {

		type WeightInfo = Self;

			);

	}

	pub enum Event<T: Config> {

		/// matching query was never registered, it may be because it is a duplicate response, or

		/// because the query timed out.

		/// no registered notification call.

		/// been dispatched and executed successfully.

		/// could not be dispatched because the dispatch weight is greater than the maximum weight

		/// originally budgeted by this runtime for the query result.

		NotifyOverweight {

		/// dispatching the notification call.

		/// decoded into a `Call`; this might be due to dispatch function having a signature which

		/// is not `(origin, QueryId, Response)`.

		/// not match that expected. The query remains registered for a later, valid, response to

		/// be received and acted upon.

		InvalidResponder {

		/// storage by this runtime previously cannot be decoded. The query remains registered.

		///

		/// This is unexpected (since a location placed in storage in a previously executing

		/// runtime should be readable prior to query timeout) and dangerous since the possibly

		/// valid response will be dropped. Manual governance intervention is probably going to be

		/// needed.

		///

		/// The cost of sending it (borne by the chain) is included.

		VersionChangeNotified {

		/// automatic notification or a manual intervention.

		/// sending the notification to it.

		/// migrating the location to our new XCM format.

		/// storage by this runtime previously cannot be decoded. The query remains registered.

		///

		/// This is unexpected (since a location placed in storage in a previously executing

		/// runtime should be readable prior to query timeout) and dangerous since the possibly

		/// valid response will be dropped. Manual governance intervention is probably going to be

		/// needed.

		/// not match the expected. The query remains registered for a later, valid, response to

		/// be received and acted upon.

		InvalidQuerier {

		/// A version information message is sent to them and its cost is included.

		/// notifications.

	}

	#[pallet::origin]

	pub enum Origin {

	}

	impl From<Location> for Origin {

	}

	pub enum Error<T> {

	}

	impl<T: Config> From<SendError> for Error<T> {

			}

	}

	impl<T: Config> From<AssetTransferError> for Error<T> {

	}

	/// The status of a query.

	pub enum QueryStatus<BlockNumber> {

		Pending {

	}

	#[derive(Copy, Clone)]

	pub(crate) struct LatestVersionedLocation<'a>(pub(crate) &'a Location);

	impl<'a> EncodeLike<VersionedLocation> for LatestVersionedLocation<'a> {}

	impl<'a> Encode for LatestVersionedLocation<'a> {

	}

	pub enum VersionMigrationStage {

	}

	impl Default for VersionMigrationStage {

	}

	/// The latest available query index.

	pub(super) type QueryCounter<T: Config> = StorageValue<_, QueryId, ValueQuery>;

	/// The ongoing queries.

	#[pallet::getter(fn query)]

	pub(super) type Queries<T: Config> =

		StorageMap<_, Blake2_128Concat, QueryId, QueryStatus<BlockNumberFor<T>>, OptionQuery>;

	/// The existing asset traps.

	///

	/// Key is the blake2 256 hash of (origin, versioned `Assets`) pair. Value is the number of

	/// times this pair has been trapped (usually just 1 if it exists at all).

	#[pallet::getter(fn asset_trap)]

	pub(super) type AssetTraps<T: Config> = StorageMap<_, Identity, H256, u32, ValueQuery>;

	/// Default version to encode XCM when latest version of destination is unknown. If `None`,

	/// then the destinations whose XCM version is unknown are considered unreachable.

	#[pallet::whitelist_storage]

	pub(super) type SafeXcmVersion<T: Config> = StorageValue<_, XcmVersion, OptionQuery>;

	/// The Latest versions that we know various locations support.

	pub(super) type SupportedVersion<T: Config> = StorageDoubleMap<

		_,

		Twox64Concat,

		XcmVersion,

		Blake2_128Concat,

		VersionedLocation,

		XcmVersion,

		OptionQuery,

	>;

	/// All locations that we have requested version notifications from.

	pub(super) type VersionNotifiers<T: Config> = StorageDoubleMap<

		_,

		Twox64Concat,

		XcmVersion,

		Blake2_128Concat,

		VersionedLocation,

		QueryId,

		OptionQuery,

	>;

	/// The target locations that are subscribed to our version changes, as well as the most recent

	/// of our versions we informed them of.

	pub(super) type VersionNotifyTargets<T: Config> = StorageDoubleMap<

		_,

		Twox64Concat,

		XcmVersion,

		Blake2_128Concat,

		VersionedLocation,

		(QueryId, Weight, XcmVersion),

		OptionQuery,

	>;

	pub struct VersionDiscoveryQueueSize<T>(PhantomData<T>);

	impl<T: Config> Get<u32> for VersionDiscoveryQueueSize<T> {

	}

	/// Destinations whose latest XCM version we would like to know. Duplicates not allowed, and

	/// the `u32` counter is the number of times that a send to the destination has been attempted,

	/// which is used as a prioritization.

	#[pallet::whitelist_storage]

	pub(super) type VersionDiscoveryQueue<T: Config> = StorageValue<

		_,

		BoundedVec<(VersionedLocation, u32), VersionDiscoveryQueueSize<T>>,

		ValueQuery,

	>;

	/// The current migration's stage, if any.

	pub(super) type CurrentMigration<T: Config> =

		StorageValue<_, VersionMigrationStage, OptionQuery>;

	#[scale_info(skip_type_params(MaxConsumers))]

	pub struct RemoteLockedFungibleRecord<ConsumerIdentifier, MaxConsumers: Get<u32>> {

		/// Total amount of the asset held by the remote lock.

		pub amount: u128,

		/// The owner of the locked asset.

		pub owner: VersionedLocation,

		/// The location which holds the original lock.

		pub locker: VersionedLocation,

		/// Local consumers of the remote lock with a consumer identifier and the amount

		/// of fungible asset every consumer holds.

		/// Every consumer can hold up to total amount of the remote lock.

		pub consumers: BoundedVec<(ConsumerIdentifier, u128), MaxConsumers>,

	}

	impl<LockId, MaxConsumers: Get<u32>> RemoteLockedFungibleRecord<LockId, MaxConsumers> {

		/// Amount of the remote lock in use by consumers.

		/// Returns `None` if the remote lock has no consumers.

	}

	/// Fungible assets which we know are locked on a remote chain.

	pub(super) type RemoteLockedFungibles<T: Config> = StorageNMap<

		_,

		(

			NMapKey<Twox64Concat, XcmVersion>,

			NMapKey<Blake2_128Concat, T::AccountId>,

			NMapKey<Blake2_128Concat, VersionedAssetId>,

		),

		RemoteLockedFungibleRecord<T::RemoteLockConsumerIdentifier, T::MaxRemoteLockConsumers>,

		OptionQuery,

	>;

	/// Fungible assets which we know are locked on this chain.

	pub(super) type LockedFungibles<T: Config> = StorageMap<

		_,

		Blake2_128Concat,

		T::AccountId,

		BoundedVec<(BalanceOf<T>, VersionedLocation), T::MaxLockers>,

		OptionQuery,

	>;

	/// Global suspension state of the XCM executor.

	pub(super) type XcmExecutionSuspended<T: Config> = StorageValue<_, bool, ValueQuery>;

	/// Whether or not incoming XCMs (both executed locally and received) should be recorded.

	/// Only one XCM program will be recorded at a time.

	/// This is meant to be used in runtime APIs, and it's advised it stays false

	/// for all other use cases, so as to not degrade regular performance.

	///

	/// Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]

	/// implementation in the XCM executor configuration.

	pub(crate) type ShouldRecordXcm<T: Config> = StorageValue<_, bool, ValueQuery>;

	/// If [`ShouldRecordXcm`] is set to true, then the last XCM program executed locally

	/// will be stored here.

	/// Runtime APIs can fetch the XCM that was executed by accessing this value.

	///

	/// Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]

	/// implementation in the XCM executor configuration.

	pub(crate) type RecordedXcm<T: Config> = StorageValue<_, Xcm<()>>;

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config> {

		#[serde(skip)]

		pub _config: core::marker::PhantomData<T>,

		/// The default version to encode outgoing XCM messages with.

		pub safe_xcm_version: Option<XcmVersion>,

	}

	impl<T: Config> Default for GenesisConfig<T> {

	}

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

	}

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

				// Consume 10% of block at most

			// Here we aim to get one successful version negotiation request sent per block, ordered

			// by the destinations being most sent to.

						// TODO: correct weights.

			}

			// Should never fail since we only removed items. But better safe than panicking as it's

			// way better to drop the queue than panic on initialize.

		#[cfg(feature = "try-runtime")]

	}

	pub mod migrations {

		use super::*;

		use frame_support::traits::{PalletInfoAccess, StorageVersion};

		enum QueryStatusV0<BlockNumber> {

		}

		impl<B> From<QueryStatusV0<B>> for QueryStatus<B> {

				use QueryStatusV0::*;

				}

		}

				target: "runtime::xcm",

				on_chain_storage_version,

			);

					target: "runtime::xcm",

					on_chain_storage_version,

				);

				// calculate and return migration weights

			} else {

					target: "runtime::xcm",

					on_chain_storage_version,

				);

			}

	}

	impl<T: Config> Pallet<T> {

		#[pallet::call_index(0)]

		pub fn send(

			origin: OriginFor<T>,

			dest: Box<VersionedLocation>,

			message: Box<VersionedXcm<()>>,

		}

		/// Teleport some assets from the local chain to some destination chain.

		///

		/// **This function is deprecated: Use `limited_teleport_assets` instead.**

		///

		/// Fee payment on the destination side is made from the asset in the `assets` vector of

		/// index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,

		/// with all fees taken as needed from the asset.

		///

		/// - `origin`: Must be capable of withdrawing the `assets` and executing XCM.

		/// - `dest`: Destination context for the assets. Will typically be `[Parent,

		///   Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from

		///   relay to parachain.

		/// - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will

		///   generally be an `AccountId32` value.

		/// - `assets`: The assets to be withdrawn. This should include the assets used to pay the

		///   fee on the `dest` chain.

		/// - `fee_asset_item`: The index into `assets` of the item which should be used to pay

		///   fees.

		#[pallet::call_index(1)]

		#[allow(deprecated)]

		#[deprecated(

			note = "This extrinsic uses `WeightLimit::Unlimited`, please migrate to `limited_teleport_assets` or `transfer_assets`"

		)]

		pub fn teleport_assets(

			origin: OriginFor<T>,

			dest: Box<VersionedLocation>,

			beneficiary: Box<VersionedLocation>,

			assets: Box<VersionedAssets>,

			fee_asset_item: u32,

		}

		/// Transfer some assets from the local chain to the destination chain through their local,

		/// destination or remote reserve.

		///

		/// `assets` must have same reserve location and may not be teleportable to `dest`.

		///  - `assets` have local reserve: transfer assets to sovereign account of destination

		///    chain and forward a notification XCM to `dest` to mint and deposit reserve-based

		///    assets to `beneficiary`.

		///  - `assets` have destination reserve: burn local assets and forward a notification to

		///    `dest` chain to withdraw the reserve assets from this chain's sovereign account and

		///    deposit them to `beneficiary`.

		///  - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move

		///    reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest`

		///    to mint and deposit reserve-based assets to `beneficiary`.

		///

		/// **This function is deprecated: Use `limited_reserve_transfer_assets` instead.**

		///

		/// Fee payment on the destination side is made from the asset in the `assets` vector of

		/// index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,

		/// with all fees taken as needed from the asset.

		///

		/// - `origin`: Must be capable of withdrawing the `assets` and executing XCM.

		/// - `dest`: Destination context for the assets. Will typically be `[Parent,

		///   Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from

		///   relay to parachain.

		/// - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will

		///   generally be an `AccountId32` value.

		/// - `assets`: The assets to be withdrawn. This should include the assets used to pay the

		///   fee on the `dest` (and possibly reserve) chains.

		/// - `fee_asset_item`: The index into `assets` of the item which should be used to pay

		///   fees.

		#[pallet::call_index(2)]

		#[allow(deprecated)]

		#[deprecated(

			note = "This extrinsic uses `WeightLimit::Unlimited`, please migrate to `limited_reserve_transfer_assets` or `transfer_assets`"

		)]

		pub fn reserve_transfer_assets(

			origin: OriginFor<T>,

			dest: Box<VersionedLocation>,

			beneficiary: Box<VersionedLocation>,

			assets: Box<VersionedAssets>,

			fee_asset_item: u32,

		}

		/// Execute an XCM message from a local, signed, origin.

		///

		/// An event is deposited indicating whether `msg` could be executed completely or only

		/// partially.

		///

		/// No more than `max_weight` will be used in its attempted execution. If this is less than

		/// the maximum amount of weight that the message could take to be executed, then no

		/// execution attempt will be made.

		#[pallet::call_index(3)]

		#[pallet::weight(max_weight.saturating_add(T::WeightInfo::execute()))]

		pub fn execute(

			origin: OriginFor<T>,

			message: Box<VersionedXcm<<T as Config>::RuntimeCall>>,

			max_weight: Weight,

		}

		/// Extoll that a particular destination can be communicated with through a particular

		/// version of XCM.

		///

		/// - `origin`: Must be an origin specified by AdminOrigin.

		/// - `location`: The destination that is being described.

		/// - `xcm_version`: The latest version of XCM that `location` supports.

		#[pallet::call_index(4)]

		pub fn force_xcm_version(

			origin: OriginFor<T>,

			location: Box<Location>,

			version: XcmVersion,

		}

		/// Set a safe XCM version (the version that XCM should be encoded with if the most recent

		/// version a destination can accept is unknown).

		///

		/// - `origin`: Must be an origin specified by AdminOrigin.

		/// - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.

		#[pallet::call_index(5)]

		pub fn force_default_xcm_version(

			origin: OriginFor<T>,

			maybe_xcm_version: Option<XcmVersion>,

		}

		/// Ask a location to notify us regarding their XCM version and any changes to it.

		///

		/// - `origin`: Must be an origin specified by AdminOrigin.

		/// - `location`: The location to which we should subscribe for XCM version notifications.

		#[pallet::call_index(6)]

		pub fn force_subscribe_version_notify(

			origin: OriginFor<T>,

			location: Box<VersionedLocation>,

				}

		}

		/// Require that a particular destination should no longer notify us regarding any XCM

		/// version changes.

		///

		/// - `origin`: Must be an origin specified by AdminOrigin.

		/// - `location`: The location to which we are currently subscribed for XCM version

		///   notifications which we no longer desire.

		#[pallet::call_index(7)]

		pub fn force_unsubscribe_version_notify(

			origin: OriginFor<T>,

			location: Box<VersionedLocation>,

				}

		}

		/// Transfer some assets from the local chain to the destination chain through their local,

		/// destination or remote reserve.

		///

		/// `assets` must have same reserve location and may not be teleportable to `dest`.

		///  - `assets` have local reserve: transfer assets to sovereign account of destination

		///    chain and forward a notification XCM to `dest` to mint and deposit reserve-based

		///    assets to `beneficiary`.

		///  - `assets` have destination reserve: burn local assets and forward a notification to

		///    `dest` chain to withdraw the reserve assets from this chain's sovereign account and

		///    deposit them to `beneficiary`.

		///  - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move

		///    reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest`

		///    to mint and deposit reserve-based assets to `beneficiary`.

		///

		/// Fee payment on the destination side is made from the asset in the `assets` vector of

		/// index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight

		/// is needed than `weight_limit`, then the operation will fail and the sent assets may be

		/// at risk.

		///

		/// - `origin`: Must be capable of withdrawing the `assets` and executing XCM.

		/// - `dest`: Destination context for the assets. Will typically be `[Parent,

		///   Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from

		///   relay to parachain.

		/// - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will

		///   generally be an `AccountId32` value.

		/// - `assets`: The assets to be withdrawn. This should include the assets used to pay the

		///   fee on the `dest` (and possibly reserve) chains.

		/// - `fee_asset_item`: The index into `assets` of the item which should be used to pay

		///   fees.

		/// - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.

		#[pallet::call_index(8)]

		#[pallet::weight(T::WeightInfo::reserve_transfer_assets())]

		pub fn limited_reserve_transfer_assets(

			origin: OriginFor<T>,

			dest: Box<VersionedLocation>,

			beneficiary: Box<VersionedLocation>,

			assets: Box<VersionedAssets>,

			fee_asset_item: u32,

			weight_limit: WeightLimit,

		}

		/// Teleport some assets from the local chain to some destination chain.

		///

		/// Fee payment on the destination side is made from the asset in the `assets` vector of

		/// index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight

		/// is needed than `weight_limit`, then the operation will fail and the sent assets may be

		/// at risk.

		///

		/// - `origin`: Must be capable of withdrawing the `assets` and executing XCM.

		/// - `dest`: Destination context for the assets. Will typically be `[Parent,

		///   Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from

		///   relay to parachain.

		/// - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will

		///   generally be an `AccountId32` value.

		/// - `assets`: The assets to be withdrawn. This should include the assets used to pay the

		///   fee on the `dest` chain.

		/// - `fee_asset_item`: The index into `assets` of the item which should be used to pay

		///   fees.

		/// - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.

		#[pallet::call_index(9)]

		#[pallet::weight(T::WeightInfo::teleport_assets())]

		pub fn limited_teleport_assets(

			origin: OriginFor<T>,

			dest: Box<VersionedLocation>,

			beneficiary: Box<VersionedLocation>,

			assets: Box<VersionedAssets>,

			fee_asset_item: u32,

			weight_limit: WeightLimit,

		}

		/// Set or unset the global suspension state of the XCM executor.

		///

		/// - `origin`: Must be an origin specified by AdminOrigin.

		/// - `suspended`: `true` to suspend, `false` to resume.

		#[pallet::call_index(10)]

		}

		/// Transfer some assets from the local chain to the destination chain through their local,

		/// destination or remote reserve, or through teleports.

		///

		/// Fee payment on the destination side is made from the asset in the `assets` vector of

		/// index `fee_asset_item` (hence referred to as `fees`), up to enough to pay for

		/// `weight_limit` of weight. If more weight is needed than `weight_limit`, then the

		/// operation will fail and the sent assets may be at risk.

		///

		/// `assets` (excluding `fees`) must have same reserve location or otherwise be teleportable

		/// to `dest`, no limitations imposed on `fees`.

		///  - for local reserve: transfer assets to sovereign account of destination chain and

		///    forward a notification XCM to `dest` to mint and deposit reserve-based assets to

		///    `beneficiary`.

		///  - for destination reserve: burn local assets and forward a notification to `dest` chain

		///    to withdraw the reserve assets from this chain's sovereign account and deposit them

		///    to `beneficiary`.

		///  - for remote reserve: burn local assets, forward XCM to reserve chain to move reserves

		///    from this chain's SA to `dest` chain's SA, and forward another XCM to `dest` to mint

		///    and deposit reserve-based assets to `beneficiary`.

		///  - for teleports: burn local assets and forward XCM to `dest` chain to mint/teleport

		///    assets and deposit them to `beneficiary`.

		///

		/// - `origin`: Must be capable of withdrawing the `assets` and executing XCM.

		/// - `dest`: Destination context for the assets. Will typically be `X2(Parent,

		///   Parachain(..))` to send from parachain to parachain, or `X1(Parachain(..))` to send

		///   from relay to parachain.

		/// - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will

		///   generally be an `AccountId32` value.

		/// - `assets`: The assets to be withdrawn. This should include the assets used to pay the

		///   fee on the `dest` (and possibly reserve) chains.

		/// - `fee_asset_item`: The index into `assets` of the item which should be used to pay

		///   fees.

		/// - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.

		#[pallet::call_index(11)]

		pub fn transfer_assets(

			origin: OriginFor<T>,

			dest: Box<VersionedLocation>,

			beneficiary: Box<VersionedLocation>,

			assets: Box<VersionedAssets>,

			fee_asset_item: u32,

			weight_limit: WeightLimit,

				target: "xcm::pallet_xcm::transfer_assets",

				origin, dest, beneficiary, assets, fee_asset_item, weight_limit,

			);

			// Find transfer types for fee and non-fee assets.

		}

		/// Claims assets trapped on this pallet because of leftover assets during XCM execution.

		///

		/// - `origin`: Anyone can call this extrinsic.

		/// - `assets`: The exact assets that were trapped. Use the version to specify what version

		/// was the latest when they were trapped.

		/// - `beneficiary`: The location/account where the claimed assets will be deposited.

		#[pallet::call_index(12)]

		pub fn claim_assets(

			origin: OriginFor<T>,

			assets: Box<VersionedAssets>,

			beneficiary: Box<VersionedLocation>,

			// Extract version from `assets`.