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

// This file is part of Cumulus.

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

//! # XCM Version 2

//!

//! WARNING: DEPRECATED, please use version 3 or 4.

//!

//! Version 2 of the Cross-Consensus Message format data structures. The comprehensive list of

//! changes can be found in

//! [this PR description](https://github.com/paritytech/polkadot/pull/3629#issue-968428279).

//!

//! ## Changes to be aware of

//! The biggest change here is the restructuring of XCM messages: instead of having `Order` and

//! `Xcm` types, the `Xcm` type now simply wraps a `Vec` containing `Instruction`s. However, most

//! changes should still be automatically convertible via the `try_from` and `from` conversion

//! functions.

//!

//! ### Junction

//! - No special attention necessary

//!

//! ### `MultiLocation`

//! - No special attention necessary

//!

//! ### `MultiAsset`

//! - No special attention necessary

//!

//! ### XCM and Order

//! - `Xcm` and `Order` variants are now combined under a single `Instruction` enum.

//! - `Order` is now obsolete and replaced entirely by `Instruction`.

//! - `Xcm` is now a simple wrapper around a `Vec<Instruction>`.

//! - During conversion from `Order` to `Instruction`, we do not handle `BuyExecution`s that have

//!   nested XCMs, i.e. if the `instructions` field in the `BuyExecution` enum struct variant is not

//!   empty, then the conversion will fail. To address this, rewrite the XCM using `Instruction`s in

//!   chronological order.

//! - During conversion from `Xcm` to `Instruction`, we do not handle `RelayedFrom` messages at all.

//!

//! ### XCM Pallet

//! - The `Weigher` configuration item must have sensible weights defined for `BuyExecution` and

//!   `DepositAsset` instructions. Failing that, dispatch calls to `teleport_assets` and

//!   `reserve_transfer_assets` will fail with `UnweighableMessage`.

use super::{

	v3::{

		BodyId as NewBodyId, BodyPart as NewBodyPart, Instruction as NewInstruction,

		NetworkId as NewNetworkId, OriginKind as NewOriginKind, Response as NewResponse,

		WeightLimit as NewWeightLimit, Xcm as NewXcm,

	},

	DoubleEncoded,

};

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

use bounded_collections::{ConstU32, WeakBoundedVec};

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 junction;

mod multiasset;

mod multilocation;

mod traits;

pub use junction::Junction;

pub use multiasset::{

	AssetId, AssetInstance, Fungibility, MultiAsset, MultiAssetFilter, MultiAssets,

	WildFungibility, WildMultiAsset,

};

pub use multilocation::{

	Ancestor, AncestorThen, InteriorMultiLocation, Junctions, MultiLocation, Parent, ParentThen,

};

pub use traits::{Error, ExecuteXcm, GetWeight, Outcome, Result, SendError, SendResult, SendXcm};

/// Basically just the XCM (more general) version of `ParachainDispatchOrigin`.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

pub enum OriginKind {

}

impl From<NewOriginKind> for OriginKind {

		use NewOriginKind::*;

		}

}

/// A global identifier of an account-bearing consensus system.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum NetworkId {

}

impl TryFrom<Option<NewNetworkId>> for NetworkId {

	type Error = ();

		}

}

impl TryFrom<NewNetworkId> for NetworkId {

	type Error = ();

		use NewNetworkId::*;

		}

}

/// An identifier of a pluralistic body.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum BodyId {

}

impl From<NewBodyId> for BodyId {

		use NewBodyId::*;

		}

}

/// A part of a pluralistic body.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum BodyPart {

	Members {

	Fraction {

	AtLeastProportion {

	MoreThanProportion {

}

impl BodyPart {

	/// Returns `true` if the part represents a strict majority (> 50%) of the body in question.

		}

}

impl From<NewBodyPart> for BodyPart {

		use NewBodyPart::*;

		}

}

/// This module's XCM version.

pub const VERSION: super::Version = 2;

/// An identifier for a query.

pub type QueryId = u64;

environmental::environmental!(instructions_count: u8);

impl<Call> Decode for Xcm<Call> {

}

/// The maximal number of instructions in an XCM before decoding fails.

///

/// This is a deliberate limit - not a technical one.

pub const MAX_INSTRUCTIONS_TO_DECODE: u8 = 100;

impl<RuntimeCall> Xcm<RuntimeCall> {

	/// Create an empty instance.

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

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

	/// 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 {

		}

}

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

pub mod prelude {

	mod contents {

		pub use super::super::{

			Ancestor, AncestorThen,

			AssetId::{self, *},

			AssetInstance::{self, *},

			BodyId, BodyPart, Error as XcmError, ExecuteXcm,

			Fungibility::{self, *},

			Instruction::*,

			InteriorMultiLocation,

			Junction::{self, *},

			Junctions::{self, *},

			MultiAsset,

			MultiAssetFilter::{self, *},

			MultiAssets, MultiLocation,

			NetworkId::{self, *},

			OriginKind, Outcome, Parent, ParentThen, QueryId, Response, Result as XcmResult,

			SendError, SendResult, SendXcm,

			WeightLimit::{self, *},

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

			WildMultiAsset::{self, *},

			XcmWeightInfo, VERSION as XCM_VERSION,

		};

	}

	pub use super::{Instruction, Xcm};

	pub use contents::*;

	pub mod opaque {

		pub use super::{

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

			contents::*,

		};

	}

}

/// Response data to a query.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum Response {

}

impl Default for Response {

}

/// An optional weight limit.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum WeightLimit {

}

impl From<Option<u64>> for WeightLimit {

		}

}

impl From<WeightLimit> for Option<u64> {

		}

}

impl TryFrom<NewWeightLimit> for WeightLimit {

	type Error = ();

		use NewWeightLimit::*;

		}

}

/// Local weight type; execution time in picoseconds.

pub type Weight = u64;

///

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

///

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

///

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

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

	/// 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:

	/// 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:

	///

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

	///

	/// Safety: No concerns.

	///

	/// 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_type`.

	///

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

	/// - `max_weight`: 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 `dest` with the given

	/// `query_id` and the outcome of the XCM.

	///

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

	/// - `dest`: A valid destination for 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:

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

	///

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

	/// - `max_assets`: The maximum number of unique assets/asset instances to remove from holding.

	///   Only the first `max_assets` assets/instances of those matched by `assets` will be

	///   removed, prioritized under standard asset ordering. Any others will remain in 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.

	/// - `max_assets`: The maximum number of unique assets/asset instances to remove from holding.

	///   Only the first `max_assets` assets/instances of those matched by `assets` will be

	///   removed, prioritized under standard asset ordering. Any others will remain in 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 asset(s) to remove from holding.

	/// - `receive`: The minimum amount of assets(s) which `give` should be exchanged for.

	///

	/// 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:

	/// portion thereof.

	///

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

	/// - `dest`: A valid destination for the returned XCM message. This may be limited to the

	///   current origin.

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

	/// - `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:

	/// 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:

	///

	/// 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*

impl<RuntimeCall> Xcm<RuntimeCall> {

}

impl<RuntimeCall> Instruction<RuntimeCall> {

		use Instruction::*;

		}

}

// TODO: Automate Generation

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

		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 response to a v2 response

impl TryFrom<NewResponse> for Response {

	type Error = ();

			}),

		})

}

// Convert from a v3 XCM to a v2 XCM.

impl<RuntimeCall> TryFrom<NewXcm<RuntimeCall>> for Xcm<RuntimeCall> {

	type Error = ();

}

// Convert from a v3 instruction to a v2 instruction

impl<RuntimeCall> TryFrom<NewInstruction<RuntimeCall>> for Instruction<RuntimeCall> {

	type Error = ();

		use NewInstruction::*;

			},

			},

			},

			},

			},

			},

			},

				// No `max_assets` here, so if there's a connt, then we cannot translate.

			},

				// No `max_assets` here, so if there's a connt, then we cannot translate.

			},

			},

			},

			},

			},

		})

}

#[cfg(test)]

mod tests {

	use super::{prelude::*, *};

	#[test]

	fn decoding_respects_limit() {

		let max_xcm = Xcm::<()>(vec![ClearOrigin; MAX_INSTRUCTIONS_TO_DECODE as usize]);

		let encoded = max_xcm.encode();

		assert!(Xcm::<()>::decode(&mut &encoded[..]).is_ok());

		let big_xcm = Xcm::<()>(vec![ClearOrigin; MAX_INSTRUCTIONS_TO_DECODE as usize + 1]);

		let encoded = big_xcm.encode();

		assert!(Xcm::<()>::decode(&mut &encoded[..]).is_err());

		let nested_xcm = Xcm::<()>(vec![

			DepositReserveAsset {

				assets: All.into(),

				dest: Here.into(),

				xcm: max_xcm,

				max_assets: 1,

			};

			(MAX_INSTRUCTIONS_TO_DECODE / 2) as usize

		]);

		let encoded = nested_xcm.encode();

		assert!(Xcm::<()>::decode(&mut &encoded[..]).is_err());

		let even_more_nested_xcm = Xcm::<()>(vec![SetAppendix(nested_xcm); 64]);

		let encoded = even_more_nested_xcm.encode();

		assert_eq!(encoded.len(), 345730);

		// This should not decode since the limit is 100

		assert_eq!(MAX_INSTRUCTIONS_TO_DECODE, 100, "precondition");

		assert!(Xcm::<()>::decode(&mut &encoded[..]).is_err());

	}

}