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

pub enum Order<Call> {
    Noop,
    DepositAsset {
        assets: MultiAssetFilter,
        max_assets: u32,
        beneficiary: MultiLocation,
    },
    DepositReserveAsset {
        assets: MultiAssetFilter,
        max_assets: u32,
        dest: MultiLocation,
        effects: Vec<Order<()>>,
    },
    ExchangeAsset {
        give: MultiAssetFilter,
        receive: MultiAssets,
    },
    InitiateReserveWithdraw {
        assets: MultiAssetFilter,
        reserve: MultiLocation,
        effects: Vec<Order<()>>,
    },
    InitiateTeleport {
        assets: MultiAssetFilter,
        dest: MultiLocation,
        effects: Vec<Order<()>>,
    },
    QueryHolding {
        query_id: u64,
        dest: MultiLocation,
        assets: MultiAssetFilter,
    },
    BuyExecution {
        fees: MultiAsset,
        weight: u64,
        debt: u64,
        halt_on_error: bool,
        instructions: Vec<Xcm<Call>>,
    },
}

Expand description

An instruction to be executed on some or all of the assets in holding, used by asset-related XCM messages.

Variants

Noop

Do nothing. Not generally used.

DepositAsset

Remove the asset(s) (assets) from holding and place equivalent assets under 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.

Errors:

Fields of DepositAsset

assets: MultiAssetFiltermax_assets: u32beneficiary: MultiLocation

DepositReserveAsset

Remove the asset(s) (assets) from holding 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 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.
effects: The orders that should be contained in the ReserveAssetDeposited which is sent onwards to dest.

Errors:

Fields of DepositReserveAsset

assets: MultiAssetFiltermax_assets: u32dest: MultiLocationeffects: Vec<Order<()>>

ExchangeAsset

Remove the asset(s) (give) from holding and replace them with alternative assets.

The minimum amount of assets to be received into holding 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.

Errors:

Fields of ExchangeAsset

give: MultiAssetFilterreceive: MultiAssets

InitiateReserveWithdraw

Remove the asset(s) (assets) from holding and send a WithdrawAsset XCM message to a 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.
effects: The orders to execute on the assets once withdrawn on the reserve location.

Errors:

Fields of InitiateReserveWithdraw

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

InitiateTeleport

Remove the asset(s) (assets) from holding and send a ReceiveTeleportedAsset XCM message to a destination location.

assets: The asset(s) to remove from holding.
destination: A valid location that has a bi-lateral teleportation arrangement.
effects: The orders to execute on the assets once arrived on the destination location.

NOTE: The destination location MUST respect this origin as a valid teleportation origin for all assets. If it does not, then the assets may be lost.

Errors:

Fields of InitiateTeleport

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

QueryHolding

Send a Balances XCM message with the assets value equal to the holding contents, or a 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.

Errors:

Fields of QueryHolding

query_id: u64dest: MultiLocationassets: MultiAssetFilter

BuyExecution

Pay for the execution of some XCM instructions and orders with up to weight picoseconds of execution time, paying for this with up to fees from the Holding Register.

fees: The asset(s) to remove from holding to pay for fees.
weight: The amount of weight to purchase; this should be at least the shallow weight of effects and xcm.
debt: The amount of weight-debt already incurred to be paid off; this should be equal to the unpaid weight of any surrounding operations/orders.
halt_on_error: If true, the execution of the orders and operations will halt on the first failure. If false, then execution will continue regardless.
instructions: XCM instructions to be executed outside of the context of the current Holding Register; execution of these instructions happens AFTER the execution of the orders. The (shallow) weight for these must be paid for with the weight purchased. Errors:

Fields of BuyExecution

fees: MultiAssetweight: u64debt: u64halt_on_error: boolinstructions: Vec<Xcm<Call>>

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

Variants

Fields of DepositAsset

Fields of DepositReserveAsset

Fields of ExchangeAsset

Fields of InitiateReserveWithdraw

Fields of InitiateTeleport

Fields of QueryHolding

Fields of BuyExecution

Implementations

impl<Call> Order<Call>

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

pub fn from<C>(order: Order<C>) -> Self

Trait Implementations

impl<Call> Clone for Order<Call>

fn clone(&self) -> Self

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

impl<Call> Debug for Order<Call>

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

impl<Call> Decode for Order<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 Order<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> PartialEq<Order<Call>> for Order<Call>

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

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

impl<Call> TryFrom<Instruction<Call>> for Order<Call>

type Error = ()

fn try_from(old: Instruction<Call>) -> Result<Order<Call>, ()>

impl<Call> TryFrom<Order<Call>> for Order<Call>

type Error = ()

fn try_from(old: Order1<Call>) -> Result<Order<Call>, ()>

impl<Call> TryFrom<Order<Call>> for Order<Call>

type Error = ()

fn try_from(old: OldOrder<Call>) -> Result<Order<Call>, ()>

impl<Call> TryFrom<Order<Call>> for Instruction<Call>

type Error = ()

fn try_from(old: OldOrder<Call>) -> Result<Instruction<Call>, ()>

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

type Identity = Self

fn type_info() -> Type

impl<Call> EncodeLike<Order<Call>> for Order<Call>

impl<Call> Eq for Order<Call>

Auto Trait Implementations

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

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

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

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

impl<Call> UnwindSafe for Order<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>

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>

impl<T> FmtForward for T

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 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 Order<Call> where
Call: 'static,

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

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

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

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

impl<Call> UnwindSafe for Order<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,

impl<T, U> TapAsRef<U> for T where
U: ?Sized,

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

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

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

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

impl<T, U> TapBorrow<U> for T where
U: ?Sized,

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

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

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

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