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

//! Cross-Consensus Message format asset data structures.

//!

//! This encompasses four types for representing assets:

//! - `MultiAsset`: A description of a single asset, either an instance of a non-fungible or some

//!   amount of a fungible.

//! - `MultiAssets`: A collection of `MultiAsset`s. These are stored in a `Vec` and sorted with

//!   fungibles first.

//! - `Wild`: A single asset wildcard, this can either be "all" assets, or all assets of a specific

//!   kind.

//! - `MultiAssetFilter`: A combination of `Wild` and `MultiAssets` designed for efficiently

//!   filtering an XCM holding account.

use super::MultiLocation;

use crate::v3::{

	AssetId as NewAssetId, AssetInstance as NewAssetInstance, Fungibility as NewFungibility,

	MultiAsset as NewMultiAsset, MultiAssetFilter as NewMultiAssetFilter,

	MultiAssets as NewMultiAssets, WildFungibility as NewWildFungibility,

	WildMultiAsset as NewWildMultiAsset,

};

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

use codec::{self as codec, Decode, Encode};

use core::cmp::Ordering;

use scale_info::TypeInfo;

/// A general identifier for an instance of a non-fungible asset class.

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

pub enum AssetInstance {

	/// supports only values up to `2**128 - 1`.

}

impl From<()> for AssetInstance {

}

impl From<[u8; 4]> for AssetInstance {

}

impl From<[u8; 8]> for AssetInstance {

}

impl From<[u8; 16]> for AssetInstance {

}

impl From<[u8; 32]> for AssetInstance {

}

impl From<Vec<u8>> for AssetInstance {

}

impl TryFrom<NewAssetInstance> for AssetInstance {

	type Error = ();

		use NewAssetInstance::*;

		})

}

/// Classification of an asset being concrete or abstract.

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

pub enum AssetId {

}

impl<T: Into<MultiLocation>> From<T> for AssetId {

}

impl From<Vec<u8>> for AssetId {

}

impl TryFrom<NewAssetId> for AssetId {

	type Error = ();

		use NewAssetId::*;

			},

		})

}

impl AssetId {

	/// Prepend a `MultiLocation` to a concrete asset, giving it a new root location.

	/// Mutate the asset to represent the same value from the perspective of a new `target`

	/// location. The local chain's location is provided in `ancestry`.

	/// Use the value of `self` along with a `fun` fungibility specifier to create the corresponding

	/// `MultiAsset` value.

	/// Use the value of `self` along with a `fun` fungibility specifier to create the corresponding

	/// `WildMultiAsset` wildcard (`AllOf`) value.

}

/// Classification of whether an asset is fungible or not, along with a mandatory amount or

/// instance.

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

pub enum Fungibility {

}

impl Fungibility {

		use Fungibility::*;

		use WildFungibility::{Fungible as WildFungible, NonFungible as WildNonFungible};

}

impl From<u128> for Fungibility {

}

impl<T: Into<AssetInstance>> From<T> for Fungibility {

}

impl TryFrom<NewFungibility> for Fungibility {

	type Error = ();

		use NewFungibility::*;

		})

}

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

pub struct MultiAsset {

	pub id: AssetId,

	pub fun: Fungibility,

}

impl PartialOrd for MultiAsset {

}

impl Ord for MultiAsset {

		}

}

impl<A: Into<AssetId>, B: Into<Fungibility>> From<(A, B)> for MultiAsset {

}

impl MultiAsset {

		use Fungibility::*;

		use Fungibility::*;

	/// Prepend a `MultiLocation` to a concrete asset, giving it a new root location.

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `ancestry`.

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `ancestry`.

	/// Returns true if `self` is a super-set of the given `inner`.

		use Fungibility::*;

			}

}

impl TryFrom<NewMultiAsset> for MultiAsset {

	type Error = ();

}

/// A `Vec` of `MultiAsset`s. There may be no duplicate fungible items in here and when decoding,

/// they must be sorted.

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

pub struct MultiAssets(Vec<MultiAsset>);

impl Decode for MultiAssets {

}

impl TryFrom<NewMultiAssets> for MultiAssets {

	type Error = ();

}

impl From<Vec<MultiAsset>> for MultiAssets {

						(

						(

						},

					}

}

impl<T: Into<MultiAsset>> From<T> for MultiAssets {

}

impl MultiAssets {

	/// A new (empty) value.

	/// Create a new instance of `MultiAssets` from a `Vec<MultiAsset>` whose contents are sorted

	/// and which contain no duplicates.

	///

	/// Returns `Ok` if the operation succeeds and `Err` if `r` is out of order or had duplicates.

	/// If you can't guarantee that `r` is sorted and deduplicated, then use

	/// `From::<Vec<MultiAsset>>::from` which is infallible.

			} else {

			}

	/// Create a new instance of `MultiAssets` from a `Vec<MultiAsset>` whose contents are sorted

	/// and which contain no duplicates.

	///

	/// In release mode, this skips any checks to ensure that `r` is correct, making it a

	/// negligible-cost operation. Generally though you should avoid using it unless you have a

	/// strict proof that `r` is valid.

	#[cfg(test)]

	pub fn from_sorted_and_deduplicated_skip_checks(r: Vec<MultiAsset>) -> Self {

		Self::from_sorted_and_deduplicated(r).expect("Invalid input r is not sorted/deduped")

	}

	/// Create a new instance of `MultiAssets` from a `Vec<MultiAsset>` whose contents are sorted

	/// and which contain no duplicates.

	///

	/// In release mode, this skips any checks to ensure that `r` is correct, making it a

	/// negligible-cost operation. Generally though you should avoid using it unless you have a

	/// strict proof that `r` is valid.

	///

	/// In test mode, this checks anyway and panics on fail.

	#[cfg(not(test))]

	/// Add some asset onto the list, saturating. This is quite a laborious operation since it

	/// maintains the ordering.

			}

	/// Returns `true` if this definitely represents no asset.

	/// Returns true if `self` is a super-set of the given `inner`.

	/// Consume `self` and return the inner vec.

	/// Return a reference to the inner vec.

	/// Return the number of distinct asset instances contained.

	/// Prepend a `MultiLocation` to any concrete asset items, giving it a new root location.

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `ancestry`.

	/// Return a reference to an item at a specific index or `None` if it doesn't exist.

}

/// Classification of whether an asset is fungible or not.

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

pub enum WildFungibility {

}

impl TryFrom<NewWildFungibility> for WildFungibility {

	type Error = ();

		use NewWildFungibility::*;

		})

}

/// A wildcard representing a set of assets.

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

pub enum WildMultiAsset {

	/// non-fungibles, then a limit is provided for the maximum amount of matching instances.

}

impl WildMultiAsset {

	/// Returns true if `self` is a super-set of the given `inner`.

	///

	/// Typically, any wildcard is never contained in anything else, and a wildcard can contain any

	/// other non-wildcard. For more details, see the implementation and tests.

		use WildMultiAsset::*;

		}

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `ancestry`.

		use WildMultiAsset::*;

		}

}

impl<A: Into<AssetId>, B: Into<WildFungibility>> From<(A, B)> for WildMultiAsset {

}

/// `MultiAsset` collection, either `MultiAssets` or a single wildcard.

///

/// Note: Vectors of wildcards whose encoding is supported in XCM v0 are unsupported

/// in this implementation and will result in a decode error.

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

pub enum MultiAssetFilter {

}

impl<T: Into<WildMultiAsset>> From<T> for MultiAssetFilter {

}

impl From<MultiAsset> for MultiAssetFilter {

}

impl From<Vec<MultiAsset>> for MultiAssetFilter {

}

impl From<MultiAssets> for MultiAssetFilter {

}

impl MultiAssetFilter {

	/// Returns true if `self` is a super-set of the given `inner`.

	///

	/// Typically, any wildcard is never contained in anything else, and a wildcard can contain any

	/// other non-wildcard. For more details, see the implementation and tests.

		}

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `ancestry`.

		}

}

impl TryFrom<NewWildMultiAsset> for WildMultiAsset {

	type Error = ();

		use NewWildMultiAsset::*;

		})

}

impl TryFrom<NewMultiAssetFilter> for MultiAssetFilter {

	type Error = ();

		use NewMultiAssetFilter::*;

		})

}