Enum xcm::v1::Xcm[−][src]

pub enum Xcm<Call> {
Show 13 variants    WithdrawAsset {
        assets: MultiAssets,
        effects: Vec<Order<Call>>,
    },
    ReserveAssetDeposited {
        assets: MultiAssets,
        effects: Vec<Order<Call>>,
    },
    ReceiveTeleportedAsset {
        assets: MultiAssets,
        effects: Vec<Order<Call>>,
    },
    QueryResponse {
        query_id: u64,
        response: Response,
    },
    TransferAsset {
        assets: MultiAssets,
        beneficiary: MultiLocation,
    },
    TransferReserveAsset {
        assets: MultiAssets,
        dest: MultiLocation,
        effects: Vec<Order<()>>,
    },
    Transact {
        origin_type: OriginKind,
        require_weight_at_most: u64,
        call: DoubleEncoded<Call>,
    },
    HrmpNewChannelOpenRequest {
        sender: u32,
        max_message_size: u32,
        max_capacity: u32,
    },
    HrmpChannelAccepted {
        recipient: u32,
    },
    HrmpChannelClosing {
        initiator: u32,
        sender: u32,
        recipient: u32,
    },
    RelayedFrom {
        who: InteriorMultiLocation,
        message: Box<Xcm<Call>>,
    },
    SubscribeVersion {
        query_id: u64,
        max_response_weight: u64,
    },
    UnsubscribeVersion,
}

Expand description

Cross-Consensus Message: A message from one consensus system to another.

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.

Variants

WithdrawAsset

Withdraw asset(s) (assets) from the ownership of origin and place them into holding. Execute the orders (effects).

assets: The asset(s) to be withdrawn into holding.
effects: The order(s) to execute on the holding register.

Kind: Instruction.

Errors:

Fields of WithdrawAsset

assets: MultiAssetseffects: Vec<Order<Call>>

ReserveAssetDeposited

Asset(s) (assets) have been received into the ownership of this system on the origin system.

Some orders are given (effects) which should be executed once the corresponding derivative assets have been placed into holding.

assets: The asset(s) that are minted into holding.
effects: The order(s) to execute on the holding register.

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:

Fields of ReserveAssetDeposited

assets: MultiAssetseffects: Vec<Order<Call>>

ReceiveTeleportedAsset

Asset(s) (assets) have been destroyed on the origin system and equivalent assets should be created on this system.

Some orders are given (effects) which should be executed once the corresponding derivative assets have been placed into the Holding Register.

assets: The asset(s) that are minted into the Holding Register.
effects: The order(s) to execute on 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:

Fields of ReceiveTeleportedAsset

assets: MultiAssetseffects: Vec<Order<Call>>

QueryResponse

Indication of the contents of the holding register corresponding to the QueryHolding order of query_id.

query_id: The identifier of the query that resulted in this message being sent.
assets: The message content.

Safety: No concerns.

Kind: Information.

Errors:

Fields of QueryResponse

query_id: u64response: Response

TransferAsset

Withdraw asset(s) (assets) from the ownership of origin and place equivalent assets under the ownership of beneficiary.

assets: The asset(s) to be withdrawn.
beneficiary: The new owner for the assets.

Safety: No concerns.

Kind: Instruction.

Errors:

Fields of TransferAsset

assets: MultiAssetsbeneficiary: MultiLocation

TransferReserveAsset

Withdraw asset(s) (assets) from the ownership of origin and place equivalent assets 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 effects.

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.
effects: The orders that should be contained in the ReserveAssetDeposited which is sent onwards to dest.

Safety: No concerns.

Kind: Instruction.

Errors:

Fields of TransferReserveAsset

assets: MultiAssetsdest: MultiLocationeffects: Vec<Order<()>>

Transact

Apply the encoded transaction call, whose dispatch-origin should be origin as expressed 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: Instruction.

Errors:

Fields of Transact

origin_type: OriginKindrequire_weight_at_most: u64call: DoubleEncoded<Call>

HrmpNewChannelOpenRequest

A message to notify about a new incoming HRMP channel. This message is meant to be sent by 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

Fields of HrmpNewChannelOpenRequest

sender: u32max_message_size: u32max_capacity: u32

HrmpChannelAccepted

A message to notify about that a previously sent open channel request has been accepted by 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:

Fields of HrmpChannelAccepted

recipient: u32

HrmpChannelClosing

A message to notify that the other party in an open channel decided to close it. In 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:

Fields of HrmpChannelClosing

initiator: u32sender: u32recipient: u32

RelayedFrom

A message to indicate that the embedded XCM is actually arriving on behalf of some consensus location within the origin.

Kind: Instruction

Errors:

Fields of RelayedFrom

who: InteriorMultiLocationmessage: Box<Xcm<Call>>

SubscribeVersion

Ask the destination system to respond with the most recent version of XCM that they support in a QueryResponse instruction. Any changes to this should also elicit similar responses when they happen.

Kind: Instruction

Fields of SubscribeVersion

query_id: u64max_response_weight: u64

UnsubscribeVersion

Cancel the effect of a previous SubscribeVersion instruction.

Kind: Instruction

Enum xcm::v1::Xcm[−][src]

Variants

Fields of WithdrawAsset

Fields of ReserveAssetDeposited

Fields of ReceiveTeleportedAsset

Fields of QueryResponse

Fields of TransferAsset

Fields of TransferReserveAsset

Fields of Transact

Fields of HrmpNewChannelOpenRequest

Fields of HrmpChannelAccepted

Fields of HrmpChannelClosing

Fields of RelayedFrom

Fields of SubscribeVersion

Implementations

impl<Call> Xcm<Call>

pub fn into<C>(self) -> Xcm<C>

pub fn from<C>(xcm: Xcm<C>) -> Self

Trait Implementations

impl<Call> Clone for Xcm<Call>

fn clone(&self) -> Self

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

impl<Call> Debug for Xcm<Call>

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

impl<Call> Decode for Xcm<Call>

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<Call> Encode for Xcm<Call>

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<Call> From<Xcm<Call>> for VersionedXcm<Call>

fn from(x: Xcm<Call>) -> Self

impl<Call> PartialEq<Xcm<Call>> for Xcm<Call>

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

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

impl<Call> TryFrom<VersionedXcm<Call>> for Xcm<Call>

type Error = ()

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

impl<Call> TryFrom<Xcm<Call>> for Xcm<Call>

type Error = ()

fn try_from(x: Xcm1<Call>) -> Result<Xcm<Call>, ()>

impl<Call> TryFrom<Xcm<Call>> for Xcm<Call>

type Error = ()

fn try_from(old: OldXcm<Call>) -> Result<Xcm<Call>, ()>

impl<Call> TryFrom<Xcm<Call>> for Xcm<Call>

type Error = ()

fn try_from(old: NewXcm<Call>) -> Result<Xcm<Call>, ()>

impl<Call> TryFrom<Xcm<Call>> for Xcm<Call>

type Error = ()

fn try_from(old: OldXcm<Call>) -> Result<Xcm<Call>, ()>

impl<Call> TypeInfo for Xcm<Call> where Call: 'static,

type Identity = Self

fn type_info() -> Type

impl<Call> EncodeLike<Xcm<Call>> for Xcm<Call>

impl<Call> Eq for Xcm<Call>

Auto Trait Implementations

impl<Call> RefUnwindSafe for Xcm<Call> where Call: RefUnwindSafe,

impl<Call> Send for Xcm<Call> where Call: Send,

impl<Call> Sync for Xcm<Call> where Call: Sync,

impl<Call> Unpin for Xcm<Call> where Call: Unpin,

impl<Call> UnwindSafe for Xcm<Call> where Call: UnwindSafe,

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

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

pub fn borrow(&self) -> &T

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

pub fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

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

impl<T> Conv for 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>

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<Call> TypeInfo for Xcm<Call> where
Call: 'static,

impl<Call> RefUnwindSafe for Xcm<Call> where
Call: RefUnwindSafe,

impl<Call> Send for Xcm<Call> where
Call: Send,

impl<Call> Sync for Xcm<Call> where
Call: Sync,

impl<Call> Unpin for Xcm<Call> where
Call: Unpin,

impl<Call> UnwindSafe for Xcm<Call> where
Call: UnwindSafe,

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,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

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

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

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

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

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

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

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

fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,

fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,