Enum xcm::v0::prelude::MultiAsset[−][src]

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,
    },
}

Expand description

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

All fungible assets of a given abstract asset identifier.

Fields of AllAbstractFungible

id: Vec<u8>

AllAbstractNonFungible

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

Fields of AllAbstractNonFungible

class: Vec<u8>

AllConcreteFungible

All fungible assets of a given concrete asset identifier.

Fields of AllConcreteFungible

id: MultiLocation

AllConcreteNonFungible

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

Fields of AllConcreteNonFungible

class: MultiLocation

AbstractFungible

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

Fields of AbstractFungible

id: Vec<u8>amount: u128

AbstractNonFungible

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

Fields of AbstractNonFungible

class: Vec<u8>instance: AssetInstance

ConcreteFungible

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

Fields of ConcreteFungible

id: MultiLocationamount: u128

ConcreteNonFungible

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

Fields of ConcreteNonFungible

class: MultiLocationinstance: AssetInstance

Enum xcm::v0::prelude::MultiAsset[−][src]

Abstract identifiers

Concrete identifiers

Variants

Fields of AllAbstractFungible

Fields of AllAbstractNonFungible

Fields of AllConcreteFungible

Fields of AllConcreteNonFungible

Fields of AbstractFungible

Fields of AbstractNonFungible

Fields of ConcreteFungible

Fields of ConcreteNonFungible

Implementations

impl MultiAsset

pub fn is_wildcard(&self) -> bool

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

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

Trait Implementations

impl Clone for MultiAsset

fn clone(&self) -> MultiAsset

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

impl Debug for MultiAsset

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

impl Decode for MultiAsset

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

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

fn encoded_fixed_size() -> Option<usize>

impl Encode for MultiAsset

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

fn size_hint(&self) -> usize

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

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

fn encoded_size(&self) -> usize

impl From<MultiAsset> for VersionedMultiAsset

fn from(x: MultiAsset) -> Self

impl Ord for MultiAsset

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

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

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

fn clamp(self, min: Self, max: Self) -> Self

impl PartialEq<MultiAsset> for MultiAsset

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

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

impl PartialOrd<MultiAsset> for MultiAsset

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

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

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

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

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

impl TryFrom<MultiAsset> for MultiAsset

type Error = ()

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

impl TryFrom<MultiAsset> for MultiAsset

type Error = ()

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

impl TryFrom<MultiAsset> for Option<MultiAsset>

type Error = ()

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

impl TryFrom<MultiAsset> for WildMultiAsset

type Error = ()

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

impl TryFrom<VersionedMultiAsset> for MultiAsset

type Error = ()

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

impl TryFrom<WildMultiAsset> for MultiAsset

type Error = ()

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

impl TypeInfo for MultiAsset

type Identity = Self

fn type_info() -> Type

impl EncodeLike<MultiAsset> for MultiAsset

impl Eq for MultiAsset

impl StructuralEq for MultiAsset

impl StructuralPartialEq for MultiAsset

Auto Trait Implementations

impl RefUnwindSafe for MultiAsset

impl Send for MultiAsset

impl Sync for MultiAsset

impl Unpin for MultiAsset

impl UnwindSafe for MultiAsset

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

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

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

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

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

impl<T> DecodeAll for T where
T: Decode,

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

impl<T> DecodeLimit for T where
T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,