Enum orml_xtokens::module::Call[−][src]

pub enum Call<T: Config> {
    transfer {
        currency_id: T::CurrencyId,
        amount: T::Balance,
        dest: Box<VersionedMultiLocation>,
        dest_weight: Weight,
    },
    transfer_multiasset {
        asset: Box<VersionedMultiAsset>,
        dest: Box<VersionedMultiLocation>,
        dest_weight: Weight,
    },
    transfer_with_fee {
        currency_id: T::CurrencyId,
        amount: T::Balance,
        fee: T::Balance,
        dest: Box<VersionedMultiLocation>,
        dest_weight: Weight,
    },
    transfer_multiasset_with_fee {
        asset: Box<VersionedMultiAsset>,
        fee: Box<VersionedMultiAsset>,
        dest: Box<VersionedMultiLocation>,
        dest_weight: Weight,
    },
    // some variants omitted
}

Expand description

Contains one variant per dispatchable that can be called by an extrinsic.

Variants

transfer

Transfer native currencies.

dest_weight is the weight for XCM execution on the dest chain, and it would be charged from the transferred assets. If set below requirements, the execution may fail and assets wouldn’t be received.

It’s a no-op if any error on local XCM execution or message sending. Note sending assets out per se doesn’t guarantee they would be received. Receiving depends on if the XCM message could be delivered by the network, and if the receiving chain would handle messages correctly.

Fields of transfer

currency_id: T::CurrencyIdamount: T::Balancedest: Box<VersionedMultiLocation>dest_weight: Weight

transfer_multiasset

Transfer MultiAsset.

dest_weight is the weight for XCM execution on the dest chain, and it would be charged from the transferred assets. If set below requirements, the execution may fail and assets wouldn’t be received.

It’s a no-op if any error on local XCM execution or message sending. Note sending assets out per se doesn’t guarantee they would be received. Receiving depends on if the XCM message could be delivered by the network, and if the receiving chain would handle messages correctly.

Fields of transfer_multiasset

asset: Box<VersionedMultiAsset>dest: Box<VersionedMultiLocation>dest_weight: Weight

transfer_with_fee

Transfer native currencies specifying the fee and amount as separate.

dest_weight is the weight for XCM execution on the dest chain, and it would be charged from the transferred assets. If set below requirements, the execution may fail and assets wouldn’t be received.

fee is the amount to be spent to pay for execution in destination chain. Both fee and amount will be subtracted form the callers balance.

If fee is not high enough to cover for the execution costs in the destination chain, then the assets will be trapped in the destination chain

It’s a no-op if any error on local XCM execution or message sending. Note sending assets out per se doesn’t guarantee they would be received. Receiving depends on if the XCM message could be delivered by the network, and if the receiving chain would handle messages correctly.

Fields of transfer_with_fee

currency_id: T::CurrencyIdamount: T::Balancefee: T::Balancedest: Box<VersionedMultiLocation>dest_weight: Weight

transfer_multiasset_with_fee

Transfer MultiAsset specifying the fee and amount as separate.

dest_weight is the weight for XCM execution on the dest chain, and it would be charged from the transferred assets. If set below requirements, the execution may fail and assets wouldn’t be received.

fee is the multiasset to be spent to pay for execution in destination chain. Both fee and amount will be subtracted form the callers balance For now we only accept fee and asset having the same MultiLocation id.

If fee is not high enough to cover for the execution costs in the destination chain, then the assets will be trapped in the destination chain

It’s a no-op if any error on local XCM execution or message sending. Note sending assets out per se doesn’t guarantee they would be received. Receiving depends on if the XCM message could be delivered by the network, and if the receiving chain would handle messages correctly.

Fields of transfer_multiasset_with_fee

asset: Box<VersionedMultiAsset>fee: Box<VersionedMultiAsset>dest: Box<VersionedMultiLocation>dest_weight: Weight

Enum orml_xtokens::module::Call[−][src]

Variants

Fields of transfer

Fields of transfer_multiasset

Fields of transfer_with_fee

Fields of transfer_multiasset_with_fee

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_transfer( currency_id: T::CurrencyId, amount: T::Balance, dest: Box<VersionedMultiLocation>, dest_weight: Weight) -> Self

pub fn new_call_variant_transfer_multiasset( asset: Box<VersionedMultiAsset>, dest: Box<VersionedMultiLocation>, dest_weight: Weight) -> Self

pub fn new_call_variant_transfer_with_fee( currency_id: T::CurrencyId, amount: T::Balance, fee: T::Balance, dest: Box<VersionedMultiLocation>, dest_weight: Weight) -> Self

pub fn new_call_variant_transfer_multiasset_with_fee( asset: Box<VersionedMultiAsset>, fee: Box<VersionedMultiAsset>, dest: Box<VersionedMultiLocation>, dest_weight: Weight) -> Self

Trait Implementations

impl<T: Config> Clone for Call<T>

fn clone(&self) -> Self

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

impl<T: Config> Debug for Call<T>

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

impl<T: Config> Decode for Call<T>

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<T: Config> Encode for Call<T>

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<T: Config> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

fn get_call_names() -> &'static [&'static str]

impl<T: Config> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

impl<T: Config> PartialEq<Call<T>> for Call<T>

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

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

impl<T: Config> TypeInfo for Call<T> where PhantomData<(T,)>: TypeInfo + 'static, T::CurrencyId: TypeInfo + 'static, T::Balance: TypeInfo + 'static, T::CurrencyId: TypeInfo + 'static, T::Balance: TypeInfo + 'static, T::Balance: TypeInfo + 'static, T: Config + 'static,

type Identity = Self

fn type_info() -> Type

impl<T: Config> UnfilteredDispatchable for Call<T>

type Origin = OriginFor<T>

fn dispatch_bypass_filter( self, origin: Self::Origin) -> DispatchResultWithPostInfo

impl<T: Config> EncodeLike<Call<T>> for Call<T>

impl<T: Config> Eq for Call<T>

Auto Trait Implementations

impl<T> RefUnwindSafe for Call<T> where T: RefUnwindSafe, <T as Config>::Balance: RefUnwindSafe, <T as Config>::CurrencyId: RefUnwindSafe,

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

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

impl<T> Unpin for Call<T> where T: Unpin, <T as Config>::Balance: Unpin, <T as Config>::CurrencyId: Unpin,

impl<T> UnwindSafe for Call<T> where T: UnwindSafe, <T as Config>::Balance: UnwindSafe, <T as Config>::CurrencyId: 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> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where Self: TryInto<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> Downcast for T where T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

pub fn as_any(&self) -> &(dyn Any + 'static)

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for T where T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

impl<T> DynClone for T where T: Clone,

pub fn __clone_box(&self, Private) -> *mut ()

impl<T> EncodeAs<T> for T where T: Encode,

pub fn new_call_variant_transfer(
currency_id: T::CurrencyId,
amount: T::Balance,
dest: Box<VersionedMultiLocation>,
dest_weight: Weight
) -> Self

pub fn new_call_variant_transfer_multiasset(
asset: Box<VersionedMultiAsset>,
dest: Box<VersionedMultiLocation>,
dest_weight: Weight
) -> Self

pub fn new_call_variant_transfer_with_fee(
currency_id: T::CurrencyId,
amount: T::Balance,
fee: T::Balance,
dest: Box<VersionedMultiLocation>,
dest_weight: Weight
) -> Self

pub fn new_call_variant_transfer_multiasset_with_fee(
asset: Box<VersionedMultiAsset>,
fee: Box<VersionedMultiAsset>,
dest: Box<VersionedMultiLocation>,
dest_weight: Weight
) -> Self

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,

fn get_call_names() -> &'static [&'static str ]

impl<T: Config> TypeInfo for Call<T> where
PhantomData<(T,)>: TypeInfo + 'static,
T::CurrencyId: TypeInfo + 'static,
T::Balance: TypeInfo + 'static,
T::CurrencyId: TypeInfo + 'static,
T::Balance: TypeInfo + 'static,
T::Balance: TypeInfo + 'static,
T: Config + 'static,

fn dispatch_bypass_filter(
self,
origin: Self::Origin
) -> DispatchResultWithPostInfo

impl<T> RefUnwindSafe for Call<T> where
T: RefUnwindSafe,
<T as Config>::Balance: RefUnwindSafe,
<T as Config>::CurrencyId: RefUnwindSafe,

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

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

impl<T> Unpin for Call<T> where
T: Unpin,
<T as Config>::Balance: Unpin,
<T as Config>::CurrencyId: Unpin,

impl<T> UnwindSafe for Call<T> where
T: UnwindSafe,
<T as Config>::Balance: UnwindSafe,
<T as Config>::CurrencyId: 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 checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,

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>

impl<T> Downcast for T where
T: Any,

impl<T> DowncastSync for T where
T: Any + Send + Sync,

impl<T> DynClone for T where
T: Clone,

impl<T> EncodeAs<T> for T where
T: Encode,

impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

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> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

pub fn blake2_256(&self) -> [u8 ; 32]

pub fn twox_128(&self) -> [u8 ; 16]

pub fn twox_256(&self) -> [u8 ; 32]

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

impl<T, Outer> IsWrappedBy<Outer> for T where
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

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,