// Copyright 2019-2025 PureStake Inc.

// This file is part of Moonbeam.

// Moonbeam 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.

// Moonbeam 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 Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

//! # Xcm Transactor Module

//!

//! ## Overview

//!

//! Module to provide transact capabilities on other chains

//!

//! In this pallet we will make distinctions between sovereign, derivative accounts and

//! multilocation-based derived accounts. The first is the account the parachain controls

//! in the destination chain, the second is an account derived from the

//! sovereign account itself, e.g., by hashing it with an index, while the third is an account

//! derived from the multilocation of a use in this chain (typically, hashing the ML).

//! Such distinction is important since we want to keep the integrity of the sovereign account

//!

//! This pallet provides three ways of sending Transact operations to another chain

//!

//! - transact_through_derivative: Transact through an address derived from this chains sovereign

//! 	account in the destination chain. For the transaction to successfully be dispatched in the

//! 	destination chain, pallet-utility needs to be installed and at least paid xcm message

//! 	execution should be allowed (and WithdrawAsset,BuyExecution and Transact messages allowed)

//! 	in the destination chain

//!

//!

//!

//! 	The transactions are dispatched from a derivative account

//! 	of the sovereign account

//! 	This pallet only stores the index of the derivative account used, but

//! 	not the derivative account itself. The only assumption this pallet makes

//! 	is the existence of the pallet_utility pallet in the destination chain

//! 	through the XcmTransact trait.

//!

//! 	All calls will be wrapped around utility::as_derivative. This makes sure

//! 	the inner call is executed from the derivative account and not the sovereign

//! 	account itself.

//!

//! 	Index registration happens through DerivativeAddressRegistrationOrigin.

//! 	This derivative account can be funded by external users to

//! 	ensure it has enough funds to make the calls

//!

//! - transact_through_sovereign: Transact through the sovereign account representing this chain.

//! 	For the transaction to successfully be dispatched in the destination chain, at least paid

//! 	xcm message execution should be allowed (and WithdrawAsset,BuyExecution and Transact

//! 	messages allowed) in the destination chain. Only callable by Root

//!

//! - transact_through_signed: Transact through an account derived from the multilocation

//! 	representing the signed user making the call. We ensure this by prepending DescendOrigin as

//! 	the first instruction of the XCM message. For the transaction to successfully be dispatched

//! 	in the destination chain, at least descended paid xcm message execution should be allowed

//! 	(and DescendOrigin + WithdrawAsset + BuyExecution + Transact messages allowed) in the

//! 	destination chain. Additionally, a ML-based derivation mechanism needs to be implemented

//! 	in the destination chain.

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

use frame_support::pallet;

use frame_support::weights::Weight;

use sp_runtime::DispatchError;

use xcm::latest::prelude::Location;

use xcm_primitives::XcmFeeTrader;

pub use pallet::*;

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

mod benchmarks;

#[cfg(test)]

pub(crate) mod mock;

#[cfg(test)]

mod tests;

pub mod encode;

pub mod migrations;

pub mod relay_indices;

pub mod weights;

pub use crate::weights::WeightInfo;

type CurrencyIdOf<T> = <T as Config>::CurrencyId;

/// TODO: Temporary (Will be removed when we have a proper way of getting pallet indices)

/// Same index on both Polkadot and Kusama Asset Hub

/// Kusama: https://github.com/polkadot-fellows/runtimes/blob/release-v2.0.0/system-parachains/asset-hubs/asset-hub-kusama/src/lib.rs#L1596

/// Polkadot: https://github.com/polkadot-fellows/runtimes/blob/release-v2.0.0/system-parachains/asset-hubs/asset-hub-polkadot/src/lib.rs#L1400

pub const ASSET_HUB_UTILITY_PALLET_INDEX: u8 = 40;

/// TODO: Temporary (Will be removed when we have a proper way of getting pallet indices)

/// Same index on both Polkadot and Kusama Asset Hub

/// Kusama: https://github.com/polkadot-fellows/runtimes/blob/release-v2.0.0/system-parachains/asset-hubs/asset-hub-kusama/src/lib.rs#L1628

/// Polkadot: https://github.com/polkadot-fellows/runtimes/blob/release-v2.0.0/system-parachains/asset-hubs/asset-hub-polkadot/src/lib.rs#L1434

pub const ASSET_HUB_STAKING_PALLET_INDEX: u8 = 89;

#[pallet]

pub mod pallet {

	use super::*;

	use crate::relay_indices::RelayChainIndices;

	use crate::weights::WeightInfo;

	use crate::CurrencyIdOf;

	use cumulus_primitives_core::{relay_chain::HrmpChannelId, ParaId};

	use frame_support::traits::EitherOfDiverse;

	use frame_support::{dispatch::DispatchResult, pallet_prelude::*};

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

	use sp_runtime::traits::{AtLeast32BitUnsigned, Convert};

	use sp_std::boxed::Box;

	use sp_std::convert::TryFrom;

	use sp_std::prelude::*;

	use sp_std::vec;

	use sp_std::vec::Vec;

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

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

	use xcm_primitives::{

		FilterMaxAssetFee, HrmpAvailableCalls, HrmpEncodeCall, UtilityAvailableCalls,

		UtilityEncodeCall, XcmTransact,

	};

	#[pallet::pallet]

	#[pallet::without_storage_info]

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

	#[pallet::config]

	pub trait Config: frame_system::Config<RuntimeEvent: From<Event<Self>>> {

		/// The balance type.

		type Balance: Parameter

			+ Member

			+ AtLeast32BitUnsigned

			+ Default

			+ Copy

			+ MaybeSerializeDeserialize

			+ Into<u128>;

		/// Currency Id.

		type CurrencyId: Parameter + Member + Clone;

		/// Convert `T::CurrencyId` to `Location`.

		type CurrencyIdToLocation: Convert<Self::CurrencyId, Option<Location>>;

		// XcmTransact needs to be implemented. This type needs to implement

		// utility call encoding and multilocation gathering

		type Transactor: Parameter + Member + Clone + XcmTransact;

		/// AssetTransactor allows us to withdraw asset without being trapped

		/// This should change in xcm v3, which allows us to burn assets

		type AssetTransactor: TransactAsset;

		// The origin that is allowed to register derivative address indices

		type DerivativeAddressRegistrationOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		// The origin that is allowed to manipulate (open, close, accept, cancel) an Hrmp channel

		type HrmpManipulatorOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		// The origin that is allowed to open and accept an Hrmp channel

		type HrmpOpenOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Convert `T::AccountId` to `Location`.

		type AccountIdToLocation: Convert<Self::AccountId, Location>;

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

		type Weigher: WeightBounds<Self::RuntimeCall>;

		/// This chain's Universal Location.

		type UniversalLocation: Get<InteriorLocation>;

		/// Self chain location.

		#[pallet::constant]

		type SelfLocation: Get<Location>;

		// The origin that is allowed to dispatch calls from the sovereign account directly

		type SovereignAccountDispatcherOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// XCM sender.

		type XcmSender: SendXcm;

		// Base XCM weight.

		///

		/// The actual weight for an XCM message is `T::BaseXcmWeight +

		/// T::Weigher::weight(&msg)`.

		#[pallet::constant]

		type BaseXcmWeight: Get<Weight>;

		/// The way to retrieve the reserve of a Asset. This can be

		/// configured to accept absolute or relative paths for self tokens

		type ReserveProvider: xcm_primitives::Reserve;

		/// The way to filter the max fee to use for HRMP management operations

		type MaxHrmpFee: FilterMaxAssetFee;

		/// Fee trader for computing XCM fees and managing asset pricing.

		/// This replaces the old `DestinationAssetFeePerSecond` storage-based approach.

		type FeeTrader: XcmFeeTrader;

		type WeightInfo: WeightInfo;

	}

	/// Stores the information to be able to issue a transact operation in another chain use an

	/// asset as fee payer.

	#[derive(

		Default,

		Clone,

		Encode,

		Decode,

		MaxEncodedLen,

		RuntimeDebug,

		Eq,

		PartialEq,

		scale_info::TypeInfo,

		DecodeWithMemTracking,

	)]

	pub struct RemoteTransactInfoWithMaxWeight {

		/// Extra weight that transacting a call in a destination chain adds

		/// Extra weight involved when transacting without DescendOrigin

		/// This should always be possible in a destination chain, since

		/// it involves going through the sovereign account

		pub transact_extra_weight: Weight,

		/// Max destination weight

		pub max_weight: Weight,

		/// Whether we allow transacting through signed origins in another chain, and

		/// how much extra cost implies

		/// Extra weight involved when transacting with DescendOrigin

		/// The reason for it being an option is because the destination chain

		/// might not support constructing origins based on generic MultiLocations

		pub transact_extra_weight_signed: Option<Weight>,

	}

	/// Enum defining the way to express a Currency.

	#[derive(

		Clone,

		Encode,

		Decode,

		Eq,

		PartialEq,

		RuntimeDebug,

		scale_info::TypeInfo,

		DecodeWithMemTracking,

	)]

	pub enum Currency<CurrencyId> {

		// Express the Currency as a CurrencyId

		AsCurrencyId(CurrencyId),

		// Express the Currency as its MultiLOcation

		AsMultiLocation(Box<VersionedLocation>),

	}

	impl<T> Default for Currency<T> {

	}

	#[derive(

		Clone,

		Encode,

		Decode,

		Eq,

		PartialEq,

		RuntimeDebug,

		scale_info::TypeInfo,

		DecodeWithMemTracking,

	)]

	pub struct HrmpInitParams {

		pub para_id: ParaId,

		pub proposed_max_capacity: u32,

		pub proposed_max_message_size: u32,

	}

	/// Enum defining the way to express a Currency.

	#[derive(

		Clone,

		Encode,

		Decode,

		Eq,

		PartialEq,

		RuntimeDebug,

		scale_info::TypeInfo,

		DecodeWithMemTracking,

	)]

	pub enum HrmpOperation {

		InitOpen(HrmpInitParams),

		Accept {

			para_id: ParaId,

		},

		Close(HrmpChannelId),

		Cancel {

			channel_id: HrmpChannelId,

			open_requests: u32,

		},

	}

	#[derive(

		Default,

		Clone,

		Encode,

		Decode,

		Eq,

		PartialEq,

		RuntimeDebug,

		MaxEncodedLen,

		scale_info::TypeInfo,

		DecodeWithMemTracking,

	)]

	/// Struct that defines how to express the payment in a particular currency

	/// currency is defined by the Currency enum, which can be expressed as:

	/// - CurrencyId

	/// - Location

	///

	/// The fee_amount is an option. In case of None, the fee will be tried to

	/// be calculated from storage. If the storage item for the currency is not

	/// populated, then it fails

	pub struct CurrencyPayment<CurrencyId> {

		// the currency in which we want to express our payment

		pub currency: Currency<CurrencyId>,

		// indicates whether we want to specify the fee amount to be used

		pub fee_amount: Option<u128>,

	}

	#[derive(

		Default,

		Clone,

		Encode,

		Decode,

		RuntimeDebug,

		PartialEq,

		scale_info::TypeInfo,

		DecodeWithMemTracking,

	)]

	/// Struct tindicating information about transact weights

	/// It allows to specify:

	/// - transact_required_weight_at_most: the amount of weight the Transact instruction

	///   should consume at most

	/// - overall_weight: the overall weight to be used for the whole XCM message execution.

	///   If None, then this amount will be tried to be derived from storage.  If the storage item

	pub struct TransactWeights {

		// the amount of weight the Transact instruction should consume at most

		pub transact_required_weight_at_most: Weight,

		// the overall weight to be used for the whole XCM message execution. If None,

		// then this amount will be tried to be derived from storage.  If the storage item

		// for the chain is not populated, then it fails

		pub overall_weight: Option<WeightLimit>,

	}

	/// The amount of ref_time and proof_size to use for fee calculation if

	/// we are dealing with an Unlimited variant inside 'overall_weight' field

	/// of 'TransactWeights' struct.

	pub const MAX_WEIGHT: Weight = Weight::from_parts(100_000_000_000, 100_000);

	/// Since we are using pallet-utility for account derivation (through AsDerivative),

	/// we need to provide an index for the account derivation. This storage item stores the index

	/// assigned for a given local account. These indices are usable as derivative in the relay chain

	#[pallet::storage]

	#[pallet::getter(fn index_to_account)]

	pub type IndexToAccount<T: Config> = StorageMap<_, Blake2_128Concat, u16, T::AccountId>;

	/// Stores the transact info of a Location. This defines how much extra weight we need to

	/// add when we want to transact in the destination chain and maximum amount of weight allowed

	/// by the destination chain

	#[pallet::storage]

	#[pallet::getter(fn transact_info)]

	pub type TransactInfoWithWeightLimit<T: Config> =

		StorageMap<_, Blake2_128Concat, Location, RemoteTransactInfoWithMaxWeight>;

	/// Stores the indices of relay chain pallets

	#[pallet::storage]

	#[pallet::getter(fn relay_indices)]

	pub type RelayIndices<T: Config> = StorageValue<_, RelayChainIndices, ValueQuery>;

	/// An error that can occur while executing the mapping pallet's logic.

	#[pallet::error]

	pub enum Error<T> {

		IndexAlreadyClaimed,

		UnclaimedIndex,

		NotOwner,

		UnweighableMessage,

		CannotReanchor,

		AssetHasNoReserve,

		InvalidDest,

		NotCrossChainTransfer,

		AssetIsNotReserveInDestination,

		DestinationNotInvertible,

		ErrorDelivering,

		DispatchWeightBiggerThanTotalWeight,

		WeightOverflow,

		AmountOverflow,

		TransactorInfoNotSet,

		NotCrossChainTransferableCurrency,

		XcmExecuteError,

		BadVersion,

		MaxWeightTransactReached,

		UnableToWithdrawAsset,

		// Removed: FeePerSecondNotSet (was index 20)

		// This error was removed. Fee-related errors are now handled by pallet-xcm-weight-trader.

		#[codec(index = 21)]

		SignedTransactNotAllowedForDestination,

		#[codec(index = 22)]

		FailedMultiLocationToJunction,

		#[codec(index = 23)]

		HrmpHandlerNotImplemented,

		#[codec(index = 24)]

		TooMuchFeeUsed,

		#[codec(index = 25)]

		ErrorValidating,

		#[codec(index = 26)]

		RefundNotSupportedWithTransactInfo,

	}

	#[pallet::event]

	#[pallet::generate_deposit(pub(crate) fn deposit_event)]

	pub enum Event<T: Config> {

		/// Transacted the inner call through a derivative account in a destination chain.

		TransactedDerivative {

			account_id: T::AccountId,

			dest: Location,

			call: Vec<u8>,

			index: u16,

		},

		/// Transacted the call through the sovereign account in a destination chain.

		TransactedSovereign {

			fee_payer: Option<T::AccountId>,

			dest: Location,

			call: Vec<u8>,

		},

		/// Transacted the call through a signed account in a destination chain.

		TransactedSigned {

			fee_payer: T::AccountId,

			dest: Location,

			call: Vec<u8>,

		},

		/// Registered a derivative index for an account id.

		RegisteredDerivative {

			account_id: T::AccountId,

			index: u16,

		},

		DeRegisteredDerivative {

			index: u16,

		},

		/// Transact failed

		TransactFailed {

			error: XcmError,

		},

		/// Changed the transact info of a location

		TransactInfoChanged {

			location: Location,

			remote_info: RemoteTransactInfoWithMaxWeight,

		},

		/// Removed the transact info of a location

		TransactInfoRemoved {

			location: Location,

		},

		// Removed: DestFeePerSecondChanged (was index 8)

		// This event was removed. Fee configuration events are now emitted by pallet-xcm-weight-trader.

		// Removed: DestFeePerSecondRemoved (was index 9)

		// This event was removed. Fee removal events are now emitted by pallet-xcm-weight-trader.

		/// HRMP manage action succesfully sent

		#[codec(index = 10)]

		HrmpManagementSent {

			action: HrmpOperation,

		},

	}

	#[pallet::genesis_config]

	pub struct GenesisConfig<T> {

		pub relay_indices: RelayChainIndices,

		#[serde(skip)]

		pub _phantom: PhantomData<T>,

	}

	impl<T> Default for GenesisConfig<T> {

	}

	#[pallet::genesis_build]

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

	}

	#[pallet::call]

	impl<T: Config> Pallet<T> {

		/// Register a derivative index for an account id. Dispatchable by

		/// DerivativeAddressRegistrationOrigin

		///

		/// We do not store the derivative address, but only the index. We do not need to store

		/// the derivative address to issue calls, only the index is enough

		///

		/// For now an index is registered for all possible destinations and not per-destination.

		/// We can change this in the future although it would just make things more complicated

		#[pallet::call_index(0)]

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

			);

			// Deposit event

		}

		/// De-Register a derivative index. This prevents an account to use a derivative address

		/// (represented by an index) from our of our sovereign accounts anymore

		#[pallet::call_index(1)]

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

			// Remove index

			// Deposit event

		}

		/// Transact the inner call through a derivative account in a destination chain,

		/// using 'fee_location' to pay for the fees. This fee_location is given as a multilocation

		///

		/// The caller needs to have the index registered in this pallet. The fee multiasset needs

		/// to be a reserve asset for the destination transactor::multilocation.

		#[pallet::call_index(2)]

		#[pallet::weight(

			Pallet::<T>::weight_of_initiate_reserve_withdraw()

			.saturating_add(T::WeightInfo::transact_through_derivative())

		)]

		pub fn transact_through_derivative(

			origin: OriginFor<T>,

			// destination to which the message should be sent

			dest: T::Transactor,

			// derivative index to be used

			index: u16,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// inner call to be executed in destination. This wiol

			// be wrapped into utility.as_derivative

			inner_call: Vec<u8>,

			// weight information to be used

			weight_info: TransactWeights,

			// add RefundSurplus and DepositAsset appendix

			refund: bool,

			// The index exists

			// The derivative index is owned by the origin

			// Encode call bytes

			// We make sure the inner call is wrapped on a as_derivative dispatchable

			);

			// Grab the destination

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

			};

			// Calculate fee based on FeePerSecond

			// If refund is true, the appendix instruction will be a deposit back to the sovereign

					])

			// Deposit event

		}

		/// Transact the call through the sovereign account in a destination chain,

		/// 'fee_payer' pays for the fee

		///

		/// SovereignAccountDispatcherOrigin callable only

		#[pallet::call_index(3)]

		#[pallet::weight(

			Pallet::<T>::weight_of_initiate_reserve_withdraw()

			.saturating_add(T::WeightInfo::transact_through_sovereign())

		)]

		pub fn transact_through_sovereign(

			origin: OriginFor<T>,

			// destination to which the message should be sent

			dest: Box<VersionedLocation>,

			// account paying for fees

			fee_payer: Option<T::AccountId>,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// call to be executed in destination

			call: Vec<u8>,

			// origin kind to be used

			origin_kind: OriginKind,

			// weight information to be used

			weight_info: TransactWeights,

			// add RefundSurplus and DepositAsset appendix

			refund: bool,

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

			};

			// Calculate fee based on FeePerSecond and total_weight

			// If refund is true, the appendix instruction will be a deposit back to the sovereign

					])

			// Grab the destination

			// Deposit event

		}

		/// Change the transact info of a location

		#[pallet::call_index(4)]

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

		pub fn set_transact_info(

			origin: OriginFor<T>,

			location: Box<VersionedLocation>,

			transact_extra_weight: Weight,

			max_weight: Weight,

			transact_extra_weight_signed: Option<Weight>,

		}

		/// Remove the transact info of a location

		#[pallet::call_index(5)]

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

		pub fn remove_transact_info(

			origin: OriginFor<T>,

			location: Box<VersionedLocation>,

			// Remove transact info

		}

		/// Transact the call through the a signed origin in this chain

		/// that should be converted to a transaction dispatch account in the destination chain

		/// by any method implemented in the destination chains runtime

		///

		/// This time we are giving the currency as a currencyId instead of multilocation

		#[pallet::call_index(6)]

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

		pub fn transact_through_signed(

			origin: OriginFor<T>,

			// destination to which the message should be sent

			dest: Box<VersionedLocation>,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// call to be executed in destination

			call: Vec<u8>,

			// weight information to be used

			weight_info: TransactWeights,

			// add RefundSurplus and DepositAsset appendix

			refund: bool,

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

			};

			// Fee to be paid

			// If refund is true, the appendix instruction will be a deposit back to the sender

					])

			// Grab the destination

			// Deposit event

		}

		// Removed: set_fee_per_second (was call_index 7)

		// This extrinsic was removed. Fee configuration is now handled by pallet-xcm-weight-trader.

		// Removed: remove_fee_per_second (was call_index 8)

		// This extrinsic was removed. Fee removal is now handled by pallet-xcm-weight-trader.

		/// Manage HRMP operations

		#[pallet::call_index(9)]

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

		pub fn hrmp_manage(

			origin: OriginFor<T>,

			action: HrmpOperation,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// weight information to be used

			weight_info: TransactWeights,

			// WithdrawAsset

			// BuyExecution

			// SetAppendix(RefundSurplus, DepositAsset(sov account))

			// Transact

			// check permissions

				HrmpOperation::InitOpen(_) | HrmpOperation::Accept { .. } => {

				}

				HrmpOperation::Close(_) | HrmpOperation::Cancel { .. } => {

				}

			}

			// process action

				}

				}

				}

				HrmpOperation::Cancel {

			}

			// Grab the destination

			// For hrmp, it is always parent

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

						false,

			};

			);

			// The appendix instruction will be a deposit back to a self location

		}

	}

	impl<T: Config> Pallet<T> {

				// Convert origin to multilocation

				// Construct the local withdraw message with the previous calculated amount

				// This message deducts and burns "amount" from the caller when executed

			// Construct the transact message. This is composed of WithdrawAsset||BuyExecution||

			// Transact.

			// WithdrawAsset: Withdraws "amount" from the sovereign account. These tokens will be

			// used to pay fees

			// BuyExecution: Buys "execution power" in the destination chain

			// Transact: Issues the transaction

			// Send to sovereign

			// Convert origin to multilocation

			// Construct the transact message. This is composed of WithdrawAsset||BuyExecution||

			// Transact.

			// WithdrawAsset: Withdraws "amount" from the sovereign account. These tokens will be

			// used to pay fees

			// BuyExecution: Buys "execution power" in the destination chain

			// Transact: Issues the transaction

			// We append DescendOrigin as the first instruction in the message

			// The new message looks like DescendOrigin||WithdrawAsset||BuyExecution||

			// Transact.

			// Send to destination chain

		/// Calculate the amount of fee based on the multilocation of the fee asset and

		/// the total weight to be spent.

		/// This now delegates to the FeeTrader instead of reading from local storage.

			// If amount is explicitly provided, keep legacy behavior: do not enforce reserve/destination

			// validation here. Historically, the reserve check only ran when converting weight->fee.

			// Otherwise, delegate to FeeTrader to compute the fee based on weight and asset pricing,

			// and validate that the fee asset is a reserve for the destination.

		/// Construct the transact xcm message with the provided parameters

			];

		/// Construct a buy execution xcm order with the provided parameters

		/// Construct a withdraw instruction from a sovereign account

		/// Construct a deposit instruction to a sovereign account

		/// Construct a withdraw instruction from a sovereign account

		/// Returns weight of `weight_of_initiate_reserve_withdraw` call.

			// We can use whatever asset here

			// Construct Asset

		/// Returns the weight information for a destination from storage

		/// it returns the weight to be used in non-signed cases

			// this is due to TransactInfo only has info of cases where RefundSurplus is not used

			// so we have to ensure 'refund' is false

			// Grab transact info for the destination provided

			);

		/// Returns the weight information for a destination from storage

		/// it returns the weight to be used in signed cases

			// this is due to TransactInfo only has info of cases where RefundSurplus is not used

			// so we have to ensure 'refund' is false

			// Grab transact info for the destination provided

			// If this storage item is not set, it means that the destination chain

			// does not support this kind of transact message

			);

		/// Get the fee per second for an asset location.

		/// This now delegates to the FeeTrader instead of reading from local storage.

		/// Converts Currency to multilocation

			}

	}

}