// Copyright (C) Parity Technologies (UK) Ltd.

// This file is part of Polkadot.

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

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

//! Version 4 of the Cross-Consensus Message format data structures.

pub use super::v3::GetWeight;

use super::v3::{

	Instruction as OldInstruction, PalletInfo as OldPalletInfo,

	QueryResponseInfo as OldQueryResponseInfo, Response as OldResponse, Xcm as OldXcm,

};

use crate::DoubleEncoded;

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

use bounded_collections::{parameter_types, BoundedVec};

use codec::{

	self, decode_vec_with_len, Compact, Decode, Encode, Error as CodecError, Input as CodecInput,

	MaxEncodedLen,

};

use core::{fmt::Debug, result};

use derivative::Derivative;

use scale_info::TypeInfo;

mod asset;

mod junction;

pub(crate) mod junctions;

mod location;

mod traits;

pub use asset::{

	Asset, AssetFilter, AssetId, AssetInstance, Assets, Fungibility, WildAsset, WildFungibility,

	MAX_ITEMS_IN_ASSETS,

};

pub use junction::{BodyId, BodyPart, Junction, NetworkId};

pub use junctions::Junctions;

pub use location::{Ancestor, AncestorThen, InteriorLocation, Location, Parent, ParentThen};

pub use traits::{

	send_xcm, validate_send, Error, ExecuteXcm, Outcome, PreparedMessage, Reanchorable, Result,

	SendError, SendResult, SendXcm, Weight, XcmHash,

};

// These parts of XCM v3 are unchanged in XCM v4, and are re-imported here.

pub use super::v3::{MaybeErrorCode, OriginKind, WeightLimit};

/// This module's XCM version.

pub const VERSION: super::Version = 4;

/// An identifier for a query.

pub type QueryId = u64;

pub const MAX_INSTRUCTIONS_TO_DECODE: u8 = 100;

environmental::environmental!(instructions_count: u8);

impl<Call> Decode for Xcm<Call> {

}

impl<Call> Xcm<Call> {

	/// Create an empty instance.

	/// Return `true` if no instructions are held in `self`.

	/// Return the number of instructions held in `self`.

	/// Return a reference to the inner value.

	/// Return a mutable reference to the inner value.

	/// Consume and return the inner value.

	/// Return an iterator over references to the items.

	/// Return an iterator over mutable references to the items.

	/// Consume and return an iterator over the items.

	/// Consume and either return `self` if it contains some instructions, or if it's empty, then

	/// instead return the result of `f`.

		} else {

		}

	/// Return the first instruction, if any.

	/// Return the last instruction, if any.

	/// Return the only instruction, contained in `Self`, iff only one exists (`None` otherwise).

		} else {

		}

	/// Return the only instruction, contained in `Self`, iff only one exists (returns `self`

	/// otherwise).

		} else {

		}

}

impl<Call> From<Vec<Instruction<Call>>> for Xcm<Call> {

}

impl<Call> From<Xcm<Call>> for Vec<Instruction<Call>> {

}

/// A prelude for importing all types typically used when interacting with XCM messages.

pub mod prelude {

	mod contents {

		pub use super::super::{

			send_xcm, validate_send, Ancestor, AncestorThen, Asset,

			AssetFilter::{self, *},

			AssetId,

			AssetInstance::{self, *},

			Assets, BodyId, BodyPart, Error as XcmError, ExecuteXcm,

			Fungibility::{self, *},

			Instruction::*,

			InteriorLocation,

			Junction::{self, *},

			Junctions::{self, Here},

			Location, MaybeErrorCode,

			NetworkId::{self, *},

			OriginKind, Outcome, PalletInfo, Parent, ParentThen, PreparedMessage, QueryId,

			QueryResponseInfo, Reanchorable, Response, Result as XcmResult, SendError, SendResult,

			SendXcm, Weight,

			WeightLimit::{self, *},

			WildAsset::{self, *},

			WildFungibility::{self, Fungible as WildFungible, NonFungible as WildNonFungible},

			XcmContext, XcmHash, XcmWeightInfo, VERSION as XCM_VERSION,

		};

	}

	pub use super::{Instruction, Xcm};

	pub use contents::*;

	pub mod opaque {

		pub use super::{

			super::opaque::{Instruction, Xcm},

			contents::*,

		};

	}

}

parameter_types! {

	pub MaxPalletNameLen: u32 = 48;

	/// Maximum size of the encoded error code coming from a `Dispatch` result, used for

	/// `MaybeErrorCode`. This is not (yet) enforced, so it's just an indication of expectation.

	pub MaxDispatchErrorLen: u32 = 128;

	pub MaxPalletsInfo: u32 = 64;

}

pub struct PalletInfo {

	#[codec(compact)]

	index: u32,

	name: BoundedVec<u8, MaxPalletNameLen>,

	module_name: BoundedVec<u8, MaxPalletNameLen>,

	#[codec(compact)]

	major: u32,

	#[codec(compact)]

	minor: u32,

	#[codec(compact)]

	patch: u32,

}

impl TryInto<OldPalletInfo> for PalletInfo {

	type Error = ();

}

impl PalletInfo {

}

/// Response data to a query.

pub enum Response {

}

impl Default for Response {

}

impl TryFrom<OldResponse> for Response {

	type Error = ();

		use OldResponse::*;

				Self::PalletsInfo(

				)

			},

		})

}

/// Information regarding the composition of a query response.

pub struct QueryResponseInfo {

	/// The destination to which the query response message should be send.

	pub destination: Location,

	/// The `query_id` field of the `QueryResponse` message.

	#[codec(compact)]

	pub query_id: QueryId,

	/// The `max_weight` field of the `QueryResponse` message.

	pub max_weight: Weight,

}

impl TryFrom<OldQueryResponseInfo> for QueryResponseInfo {

	type Error = ();

		})

}

/// Contextual data pertaining to a specific list of XCM instructions.

#[derive(Clone, Eq, PartialEq, Encode, Decode, Debug)]

pub struct XcmContext {

	/// The current value of the Origin register of the `XCVM`.

	pub origin: Option<Location>,

	/// The identity of the XCM; this may be a hash of its versioned encoding but could also be

	/// a high-level identity set by an appropriate barrier.

	pub message_id: XcmHash,

	/// The current value of the Topic register of the `XCVM`.

	pub topic: Option<[u8; 32]>,

}

impl XcmContext {

	/// Constructor which sets the message ID to the supplied parameter and leaves the origin and

	/// topic unset.

}

///

/// Consensus systems that may send and receive messages include blockchains and smart contracts.

///

/// All messages are delivered from a known *origin*, expressed as a `Location`.

///

/// This is the inner XCM format and is version-sensitive. Messages are typically passed using the

/// outer XCM format, known as `VersionedXcm`.

#[derive(

	/// system and equivalent derivatives should be placed into the Holding Register.

	///

	/// - `assets`: The asset(s) that are minted into holding.

	///

	/// Safety: `origin` must be trusted to have received and be storing `assets` such that they

	/// may later be withdrawn should this system send a corresponding message.

	///

	/// Kind: *Trusted Indication*.

	///

	/// Errors:

	#[builder(loads_holding)]

	/// be created and placed into the Holding Register.

	///

	/// - `assets`: The asset(s) that are minted into the Holding Register.

	///

	/// Safety: `origin` must be trusted to have irrevocably destroyed the corresponding `assets`

	/// prior as a consequence of sending this message.

	///

	/// Kind: *Trusted Indication*.

	///

	/// Errors:

	#[builder(loads_holding)]

	///

	/// - `query_id`: The identifier of the query that resulted in this message being sent.

	/// - `response`: The message content.

	/// - `max_weight`: The maximum weight that handling this response should take.

	/// - `querier`: The location responsible for the initiation of the response, if there is one.

	///   In general this will tend to be the same location as the receiver of this message. NOTE:

	///   As usual, this is interpreted from the perspective of the receiving consensus system.

	///

	/// Safety: Since this is information only, there are no immediate concerns. However, it should

	/// be remembered that even if the Origin behaves reasonably, it can always be asked to make

	/// a response to a third-party chain who may or may not be expecting the response. Therefore

	/// the `querier` should be checked to match the expected value.

	///

	/// Kind: *Information*.

	///

	/// Errors:

	/// under the ownership of `beneficiary`.

	///

	/// - `assets`: The asset(s) to be withdrawn.

	/// - `beneficiary`: The new owner for the assets.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*.

	///

	/// Errors:

	/// under the ownership of `dest` within this consensus system (i.e. its sovereign account).

	///

	/// Send an onward XCM message to `dest` of `ReserveAssetDeposited` with the given

	/// `xcm`.

	///

	/// - `assets`: The asset(s) to be withdrawn.

	/// - `dest`: The location whose sovereign account will own the assets and thus the effective

	///   beneficiary for the assets and the notification target for the reserve asset deposit

	///   message.

	/// - `xcm`: The instructions that should follow the `ReserveAssetDeposited` instruction, which

	///   is sent onwards to `dest`.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*.

	///

	/// Errors:

	/// by the kind of origin `origin_kind`.

	///

	/// The Transact Status Register is set according to the result of dispatching the call.

	///

	/// - `origin_kind`: The means of expressing the message origin as a dispatch origin.

	/// - `require_weight_at_most`: The weight of `call`; this should be at least the chain's

	///   calculated weight and will be used in the weight determination arithmetic.

	/// - `call`: The encoded transaction to be applied.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*.

	///

	/// Errors:

	/// the relay-chain to a para.

	///

	/// - `sender`: The sender in the to-be opened channel. Also, the initiator of the channel

	///   opening.

	/// - `max_message_size`: The maximum size of a message proposed by the sender.

	/// - `max_capacity`: The maximum number of messages that can be queued in the channel.

	///

	/// Safety: The message should originate directly from the relay-chain.

	///

	/// Kind: *System Notification*

	/// the recipient. That means that the channel will be opened during the next relay-chain

	/// session change. This message is meant to be sent by the relay-chain to a para.

	///

	/// Safety: The message should originate directly from the relay-chain.

	///

	/// Kind: *System Notification*

	///

	/// Errors:

		// NOTE: We keep this as a structured item to a) keep it consistent with the other Hrmp

		// items; and b) because the field's meaning is not obvious/mentioned from the item name.

	/// particular, `initiator` is going to close the channel opened from `sender` to the

	/// `recipient`. The close will be enacted at the next relay-chain session change. This message

	/// is meant to be sent by the relay-chain to a para.

	///

	/// Safety: The message should originate directly from the relay-chain.

	///

	/// Kind: *System Notification*

	///

	/// Errors:

	///

	/// Kind: *Command*

	///

	/// Errors:

	///

	/// A `QueryResponse` message of type `ExecutionOutcome` is sent to the described destination.

	///

	/// - `response_info`: Information for making the response.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// the ownership of `beneficiary` within this consensus system.

	///

	/// - `assets`: The asset(s) to remove from holding.

	/// - `beneficiary`: The new owner for the assets.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// the ownership of `dest` within this consensus system (i.e. deposit them into its sovereign

	/// account).

	///

	/// Send an onward XCM message to `dest` of `ReserveAssetDeposited` with the given `effects`.

	///

	/// - `assets`: The asset(s) to remove from holding.

	/// - `dest`: The location whose sovereign account will own the assets and thus the effective

	///   beneficiary for the assets and the notification target for the reserve asset deposit

	///   message.

	/// - `xcm`: The orders that should follow the `ReserveAssetDeposited` instruction which is

	///   sent onwards to `dest`.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// assets.

	///

	/// The minimum amount of assets to be received into the Holding Register for the order not to

	/// fail may be stated.

	///

	/// - `give`: The maximum amount of assets to remove from holding.

	/// - `want`: The minimum amount of assets which `give` should be exchanged for.

	/// - `maximal`: If `true`, then prefer to give as much as possible up to the limit of `give`

	///   and receive accordingly more. If `false`, then prefer to give as little as possible in

	///   order to receive as little as possible while receiving at least `want`.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// reserve location.

	///

	/// - `assets`: The asset(s) to remove from holding.

	/// - `reserve`: A valid location that acts as a reserve for all asset(s) in `assets`. The

	///   sovereign account of this consensus system *on the reserve location* will have

	///   appropriate assets withdrawn and `effects` will be executed on them. There will typically

	///   be only one valid location on any given asset/chain combination.

	/// - `xcm`: The instructions to execute on the assets once withdrawn *on the reserve

	///   location*.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// to a `dest` location.

	///

	/// - `assets`: The asset(s) to remove from holding.

	/// - `dest`: A valid location that respects teleports coming from this location.

	/// - `xcm`: The instructions to execute on the assets once arrived *on the destination

	///   location*.

	///

	/// NOTE: The `dest` location *MUST* respect this origin as a valid teleportation origin for

	/// all `assets`. If it does not, then the assets may be lost.

	///

	/// Kind: *Command*

	///

	/// Errors:

	///

	/// A `QueryResponse` message of type `Assets` is sent to the described destination.

	///

	/// - `response_info`: Information for making the response.

	/// - `assets`: A filter for the assets that should be reported back. The assets reported back

	///   will be, asset-wise, *the lesser of this value and the holding register*. No wildcards

	///   will be used when reporting assets back.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// picoseconds of execution time, paying for this with up to `fees` from the Holding Register.

	///

	/// - `fees`: The asset(s) to remove from the Holding Register to pay for fees.

	/// - `weight_limit`: The maximum amount of weight to purchase; this must be at least the

	///   expected maximum weight of the total XCM to be executed for the

	///   `AllowTopLevelPaidExecutionFrom` barrier to allow the XCM be executed.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// happening.

	///

	/// An error occurring within execution of this code will _NOT_ result in the error register

	/// being set, nor will an error handler be called due to it. The error handler and appendix

	/// may each still be set.

	///

	/// The apparent weight of this instruction is inclusive of the inner `Xcm`; the executing

	/// weight however includes only the difference between the previous handler and the new

	/// handler, which can reasonably be negative, which would result in a surplus.

	///

	/// Kind: *Command*

	///

	/// Errors: None.

	/// (including the error handler if any) is finished. This will be called regardless of whether

	/// an error occurred.

	///

	/// Any error occurring due to execution of this code will result in the error register being

	/// set, and the error handler (if set) firing.

	///

	/// The apparent weight of this instruction is inclusive of the inner `Xcm`; the executing

	/// weight however includes only the difference between the previous appendix and the new

	/// appendix, which can reasonably be negative, which would result in a surplus.

	///

	/// Kind: *Command*

	///

	/// Errors: None.

	///

	/// - `assets`: The assets which are to be claimed. This must match exactly with the assets

	///   claimable by the origin of the ticket.

	/// - `ticket`: The ticket of the asset; this is an abstract identifier to help locate the

	///   asset.

	///

	/// Kind: *Command*

	///

	/// Errors:

	#[builder(loads_holding)]

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// - `Trap`: All circumstances, whose inner value is the same as this item's inner value.

	/// support in a `QueryResponse` instruction. Any changes to this should also elicit similar

	/// responses when they happen.

	///

	/// - `query_id`: An identifier that will be replicated into the returned XCM message.

	/// - `max_response_weight`: The maximum amount of weight that the `QueryResponse` item which

	///   is sent as a reply may take to execute. NOTE: If this is unexpectedly large then the

	///   response may not execute at all.

	///

	/// Kind: *Command*

	///

	/// Errors: *Fallible*

	///

	/// Holding is reduced by as much as possible up to the assets in the parameter. It is not an

	/// error if the Holding does not contain the assets (to make this an error, use `ExpectAsset`

	/// prior).

	///

	/// Kind: *Command*

	///

	/// Errors: *Infallible*

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// - `ExpectationFalse`: If Holding Register does not contain the assets in the parameter.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// - `ExpectationFalse`: If Origin Register is not equal to the parameter.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// - `ExpectationFalse`: If the value of the Error Register is not equal to the parameter.

	/// not.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// - `ExpectationFalse`: If the value of the Transact Status Register is not equal to the

	///   parameter.

	///

	/// - `module_name`: The module name of the pallet to query.

	/// - `response_info`: Information for making the response.

	///

	/// Sends a `QueryResponse` to Origin whose data field `PalletsInfo` containing the information

	/// of all pallets on the local chain whose name is equal to `name`. This is empty in the case

	/// that the local chain is not based on Substrate Frame.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*

	///

	/// Errors: *Fallible*.

	///

	/// - `index: Compact`: The index which identifies the pallet. An error if no pallet exists at

	///   this index.

	/// - `name: Vec<u8>`: Name which must be equal to the name of the pallet.

	/// - `module_name: Vec<u8>`: Module name which must be equal to the name of the module in

	///   which the pallet exists.

	/// - `crate_major: Compact`: Version number which must be equal to the major version of the

	///   crate which implements the pallet.

	/// - `min_crate_minor: Compact`: Version number which must be at most the minor version of the

	///   crate which implements the pallet.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*

	///

	/// Errors:

	/// - `ExpectationFalse`: In case any of the expectations are broken.

	/// destination.

	///

	/// - `query_response_info`: The information needed for constructing and sending the

	///   `QueryResponse` message.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*

	///

	/// Errors: *Fallible*.

	///

	/// Safety: Should only be usable if the Origin is trusted to represent the Universal Ancestor

	/// child in general. In general, no Origin should be able to represent the Universal Ancestor

	/// child which is the root of the local consensus system since it would by extension

	/// allow it to act as any location within the local consensus.

	///

	/// The `Junction` parameter should generally be a `GlobalConsensus` variant since it is only

	/// these which are children of the Universal Ancestor.

	///

	/// Kind: *Command*

	///

	/// Errors: *Fallible*.

	///

	/// This will tend to utilize some extra-consensus mechanism, the obvious one being a bridge.

	/// A fee may be charged; this may be determined based on the contents of `xcm`. It will be

	/// taken from the Holding register.

	///

	/// - `network`: The remote consensus system to which the message should be exported.

	/// - `destination`: The location relative to the remote consensus system to which the message

	///   should be sent on arrival.

	/// - `xcm`: The message to be exported.

	///

	/// As an example, to export a message for execution on Statemine (parachain #1000 in the

	/// Kusama network), you would call with `network: NetworkId::Kusama` and

	/// `destination: [Parachain(1000)].into()`. Alternatively, to export a message for execution

	/// on Polkadot, you would call with `network: NetworkId:: Polkadot` and `destination: Here`.

	///

	/// Kind: *Command*

	///

	/// Errors: *Fallible*.

	///

	/// This restriction may be removed by the `UnlockAsset` instruction being called with an

	/// Origin of `unlocker` and a `target` equal to the current `Origin`.

	///

	/// If the locking is successful, then a `NoteUnlockable` instruction is sent to `unlocker`.

	///

	/// - `asset`: The asset(s) which should be locked.

	/// - `unlocker`: The value which the Origin must be for a corresponding `UnlockAsset`

	///   instruction to work.

	///

	/// Kind: *Command*.

	///

	/// Errors:

	/// asset to be transferred.

	///

	/// - `asset`: The asset to be unlocked.

	/// - `target`: The owner of the asset on the local chain.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*.

	///

	/// Errors:

	/// only be unlocked with the receipt of the `UnlockAsset` instruction from this chain.

	///

	/// - `asset`: The asset(s) which are now unlockable from this origin.

	/// - `owner`: The owner of the asset on the chain in which it was locked. This may be a

	///   location specific to the origin network.

	///

	/// Safety: `origin` must be trusted to have locked the corresponding `asset`

	/// prior as a consequence of sending this message.

	///

	/// Kind: *Trusted Indication*.

	///

	/// Errors:

	///

	/// This may fail if the local system is making use of the fact that the asset is locked or,

	/// of course, if there is no record that the asset actually is locked.

	///

	/// - `asset`: The asset(s) to be unlocked.

	/// - `locker`: The location from which a previous `NoteUnlockable` was sent and to which an

	///   `UnlockAsset` should be sent.

	///

	/// Kind: *Command*.

	///

	/// Errors:

	///

	/// - `jit_withdraw`: The fees mode item; if set to `true` then fees for any instructions are

	///   withdrawn as needed using the same mechanism as `WithdrawAssets`.

	///

	/// Kind: *Command*.

	///

	/// Errors:

	///

	/// The 32-byte array identifier in the parameter is not guaranteed to be

	/// unique; if such a property is desired, it is up to the code author to

	/// enforce uniqueness.

	///

	/// Safety: No concerns.

	///

	/// Kind: *Command*

	///

	/// Errors:

	///

	/// Kind: *Command*

	///

	/// Errors: If the existing state would not allow such a change.

	///

	/// At execution time, this instruction just does a check on the Origin register.

	/// However, at the barrier stage messages starting with this instruction can be disregarded if

	/// the origin is not acceptable for free execution or the `weight_limit` is `Limited` and

	/// insufficient.

	///

	/// Kind: *Indication*

	///

	/// Errors: If the given origin is `Some` and not equal to the current Origin register.

impl<Call> Xcm<Call> {

}

impl<Call> Instruction<Call> {

		use Instruction::*;

		}

}

// TODO: Automate Generation

impl<Call, W: XcmWeightInfo<Call>> GetWeight<W> for Instruction<Call> {

		use Instruction::*;

		}

}

pub mod opaque {

	/// The basic concrete type of `Xcm`, which doesn't make any assumptions about the

	/// format of a call other than it is pre-encoded.

	pub type Xcm = super::Xcm<()>;

	/// The basic concrete type of `Instruction`, which doesn't make any assumptions about the

	/// format of a call other than it is pre-encoded.

	pub type Instruction = super::Instruction<()>;

}

// Convert from a v3 XCM to a v4 XCM

impl<Call> TryFrom<OldXcm<Call>> for Xcm<Call> {

	type Error = ();

}

// Convert from a v3 instruction to a v4 instruction

impl<Call> TryFrom<OldInstruction<Call>> for Instruction<Call> {

	type Error = ();

		use OldInstruction::*;

				},

				},

			},

			},

			}),

			},

			},

			},

			},

			},

			},

			},

			},

			),

			),

			},