Enum xcm::v0::MultiAsset

pub enum MultiAsset {
    None,
    All,
    AllFungible,
    AllNonFungible,
    AllAbstractFungible {
        id: Vec<u8>,
    },
    AllAbstractNonFungible {
        class: Vec<u8>,
    },
    AllConcreteFungible {
        id: MultiLocation,
    },
    AllConcreteNonFungible {
        class: MultiLocation,
    },
    AbstractFungible {
        id: Vec<u8>,
        amount: u128,
    },
    AbstractNonFungible {
        class: Vec<u8>,
        instance: AssetInstance,
    },
    ConcreteFungible {
        id: MultiLocation,
        amount: u128,
    },
    ConcreteNonFungible {
        class: MultiLocation,
        instance: AssetInstance,
    },
}

A single general identifier for an asset.

Represents both fungible and non-fungible assets. May only be used to represent a single asset class.

Wildcards may or may not be allowed by the interpreting context.

Assets classes may be identified in one of two ways: either an abstract identifier or a concrete identifier. Implementations may support only one of these. A single asset may be referenced from multiple asset identifiers, though will tend to have only a single preferred identifier.

Abstract identifiers

Abstract identifiers are absolute identifiers that represent a notional asset which can exist within multiple consensus systems. These tend to be simpler to deal with since their broad meaning is unchanged regardless stay of the consensus system in which it is interpreted.

However, in the attempt to provide uniformity across consensus systems, they may conflate different instantiations of some notional asset (e.g. the reserve asset and a local reserve-backed derivative of it) under the same name, leading to confusion. It also implies that one notional asset is accounted for locally in only one way. This may not be the case, e.g. where there are multiple bridge instances each providing a bridged “BTC” token yet none being fungible between the others.

Since they are meant to be absolute and universal, a global registry is needed to ensure that name collisions do not occur.

An abstract identifier is represented as a simple variable-size byte string. As of writing, no global registry exists and no proposals have been put forth for asset labeling.

Concrete identifiers

Concrete identifiers are relative identifiers that specifically identify a single asset through its location in a consensus system relative to the context interpreting. Use of a MultiLocation ensures that similar but non fungible variants of the same underlying asset can be properly distinguished, and obviates the need for any kind of central registry.

The limitation is that the asset identifier cannot be trivially copied between consensus systems and must instead be “re-anchored” whenever being moved to a new consensus system, using the two systems’ relative paths.

Throughout XCM, messages are authored such that when interpreted from the receiver’s point of view they will have the desired meaning/effect. This means that relative paths should always by constructed to be read from the point of view of the receiving system, which may be have a completely different meaning in the authoring system.

Concrete identifiers are the preferred way of identifying an asset since they are entirely unambiguous.

A concrete identifier is represented by a MultiLocation. If a system has an unambiguous primary asset (such as Bitcoin with BTC or Ethereum with ETH), then it will conventionally be identified as the chain itself. Alternative and more specific ways of referring to an asset within a system include:

• <chain>/PalletInstance(<id>) for a Frame chain with a single-asset pallet instance (such as an instance of the Balances pallet).
• <chain>/PalletInstance(<id>)/GeneralIndex(<index>) for a Frame chain with an indexed multi-asset pallet instance (such as an instance of the Assets pallet).
• <chain>/AccountId32 for an ERC-20-style single-asset smart-contract on a Frame-based contracts chain.
• <chain>/AccountKey20 for an ERC-20-style single-asset smart-contract on an Ethereum-like chain.

Variants

None

No assets. Rarely used.

All

All assets. Typically used for the subset of assets to be used for an Order, and in that context means “all assets currently in holding”.

AllFungible

All fungible assets. Typically used for the subset of assets to be used for an Order, and in that context means “all fungible assets currently in holding”.

AllNonFungible

All non-fungible assets. Typically used for the subset of assets to be used for an Order, and in that context means “all non-fungible assets currently in holding”.

AllAbstractFungible

Fields

id: Vec<u8>

All fungible assets of a given abstract asset identifier.

AllAbstractNonFungible

Fields

class: Vec<u8>

All non-fungible assets of a given abstract asset class.

AllConcreteFungible

Fields

id: MultiLocation

All fungible assets of a given concrete asset identifier.

AllConcreteNonFungible

Fields

class: MultiLocation

All non-fungible assets of a given concrete asset class.

AbstractFungible

Fields

id: Vec<u8>

amount: u128

Some specific amount of the fungible asset identified by an abstract id.

AbstractNonFungible

Fields

class: Vec<u8>

instance: AssetInstance

Some specific instance of the non-fungible asset whose class is identified abstractly.

ConcreteFungible

Fields

id: MultiLocation

amount: u128

Some specific amount of the fungible asset identified by an concrete id.

ConcreteNonFungible

Fields

class: MultiLocation

instance: AssetInstance

Some specific instance of the non-fungible asset whose class is identified concretely.

Implementations

impl MultiAsset

pub fn is_wildcard(&self) -> bool

Returns true if the MultiAsset is a wildcard and can refer to classes of assets, instead of just one.

Typically can also be inferred by the name starting with All.

pub fn contains(&self, inner: &MultiAsset) -> bool

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.

pub fn reanchor(&mut self, prepend: &MultiLocation) -> Result<(), ()>

Trait Implementations

impl Clone for MultiAsset

fn clone(&self) -> MultiAsset

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MultiAsset

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for MultiAsset

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error>where
    I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Encode for MultiAsset

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl From<MultiAsset> for VersionedMultiAsset

fn from(x: MultiAsset) -> Self

Converts to this type from the input type.

impl Ord for MultiAsset

fn cmp(&self, other: &MultiAsset) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<MultiAsset> for MultiAsset

fn eq(&self, other: &MultiAsset) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<MultiAsset> for MultiAsset

fn partial_cmp(&self, other: &MultiAsset) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<MultiAsset> for MultiAsset

type Error = ()

The type returned in the event of a conversion error.

fn try_from(m: MultiAsset) -> Result<MultiAsset, ()>

Performs the conversion.

impl TryFrom<MultiAsset> for MultiAsset

type Error = ()

The type returned in the event of a conversion error.

fn try_from(old: MultiAsset) -> Result<MultiAsset, ()>

Performs the conversion.

impl TryFrom<MultiAsset> for Option<MultiAsset>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(old: MultiAsset) -> Result<Option<MultiAsset>, ()>

Performs the conversion.

impl TryFrom<MultiAsset> for WildMultiAsset

type Error = ()

The type returned in the event of a conversion error.

fn try_from(old: MultiAsset) -> Result<WildMultiAsset, ()>

Performs the conversion.

impl TryFrom<VersionedMultiAsset> for MultiAsset

type Error = ()

The type returned in the event of a conversion error.

fn try_from(x: VersionedMultiAsset) -> Result<Self, ()>

Performs the conversion.

impl TryFrom<WildMultiAsset> for MultiAsset

type Error = ()

The type returned in the event of a conversion error.

fn try_from(m: WildMultiAsset) -> Result<MultiAsset, ()>

Performs the conversion.

impl TypeInfo for MultiAsset

type Identity = MultiAsset

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike<MultiAsset> for MultiAsset

impl Eq for MultiAsset

impl StructuralEq for MultiAsset

impl StructuralPartialEq for MultiAsset