Struct xcm_executor::XcmExecutor

source ·

pub struct XcmExecutor<Config: Config> {
    pub holding: Assets,
    pub origin: Option<MultiLocation>,
    pub original_origin: MultiLocation,
    pub trader: Config::Trader,
    pub error: Option<(u32, XcmError)>,
    pub total_surplus: u64,
    pub total_refunded: u64,
    pub error_handler: Xcm<Config::RuntimeCall>,
    pub error_handler_weight: u64,
    pub appendix: Xcm<Config::RuntimeCall>,
    pub appendix_weight: u64,
    /* private fields */
}

Expand description

The XCM executor.

Fields§

§holding: Assets§origin: Option<MultiLocation>§original_origin: MultiLocation§trader: Config::Trader§error: Option<(u32, XcmError)>

The most recent error result and instruction index into the fragment in which it occurred, if any.

§total_surplus: u64

The surplus weight, defined as the amount by which max_weight is an over-estimate of the actual weight consumed. We do it this way to avoid needing the execution engine to keep track of all instructions’ weights (it only needs to care about the weight of dynamically determined instructions such as Transact).

§total_refunded: u64§error_handler: Xcm<Config::RuntimeCall>§error_handler_weight: u64§appendix: Xcm<Config::RuntimeCall>§appendix_weight: u64

Struct xcm_executor::XcmExecutor

Fields§

Implementations§

impl<Config: Config> XcmExecutor<Config>

pub fn new(origin: impl Into<MultiLocation>) -> Self

pub fn execute( &mut self, xcm: Xcm<Config::RuntimeCall> ) -> Result<(), ExecutorError>

pub fn post_execute(self, xcm_weight: Weight) -> Outcome

Trait Implementations§

impl<Config: Config> ExecuteXcm<<Config as Config>::RuntimeCall> for XcmExecutor<Config>

fn execute_xcm_in_credit( origin: impl Into<MultiLocation>, message: Xcm<Config::RuntimeCall>, weight_limit: Weight, weight_credit: Weight ) -> Outcome

fn execute_xcm( origin: impl Into<MultiLocation>, message: Xcm<RuntimeCall>, weight_limit: u64 ) -> Outcome

Auto Trait Implementations§

impl<Config> RefUnwindSafe for XcmExecutor<Config>where Config: RefUnwindSafe, <Config as Config>::RuntimeCall: RefUnwindSafe, <Config as Config>::Trader: RefUnwindSafe,

impl<Config> Send for XcmExecutor<Config>where Config: Send, <Config as Config>::RuntimeCall: Send, <Config as Config>::Trader: Send,

impl<Config> Sync for XcmExecutor<Config>where Config: Sync, <Config as Config>::RuntimeCall: Sync, <Config as Config>::Trader: Sync,

impl<Config> Unpin for XcmExecutor<Config>where Config: Unpin, <Config as Config>::RuntimeCall: Unpin, <Config as Config>::Trader: Unpin,

impl<Config> UnwindSafe for XcmExecutor<Config>where Config: UnwindSafe, <Config as Config>::RuntimeCall: UnwindSafe, <Config as Config>::Trader: UnwindSafe,

Blanket Implementations§

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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) -> Twhere Self: Into<T>,

impl<T> Downcast for Twhere T: Any,

fn into_any(self: Box<T, Global>) -> Box<dyn Any, Global>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

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

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

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

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

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 fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

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

fn into(self) -> U

impl<T> IsType<T> for T

fn from_ref(t: &T) -> &T

fn into_ref(&self) -> &T

fn from_mut(t: &mut T) -> &mut T

fn into_mut(&mut self) -> &mut T

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

fn from_ref(outer: &Outer) -> &T

fn from_mut(outer: &mut Outer) -> &mut T

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

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

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

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

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere 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 ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere 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) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere 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 ) -> Rwhere Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same<T> for T

type Output = T