Trait sp_runtime::traits::transaction_extension::DispatchTransaction

pub trait DispatchTransaction<Call: Dispatchable> {
    type Origin;
    type Info;
    type Result;
    type Val;
    type Pre;

    // Required methods
    fn validate_only(
        &self,
        origin: Self::Origin,
        call: &Call,
        info: &Self::Info,
        len: usize,
    ) -> Result<(ValidTransaction, Self::Val, Self::Origin), TransactionValidityError>;
    fn validate_and_prepare(
        self,
        origin: Self::Origin,
        call: &Call,
        info: &Self::Info,
        len: usize,
    ) -> Result<(Self::Pre, Self::Origin), TransactionValidityError>;
    fn dispatch_transaction(
        self,
        origin: Self::Origin,
        call: Call,
        info: &Self::Info,
        len: usize,
    ) -> Self::Result;
    fn test_run(
        self,
        origin: Self::Origin,
        call: &Call,
        info: &Self::Info,
        len: usize,
        substitute: impl FnOnce(Self::Origin) -> DispatchResultWithInfo<<Call as Dispatchable>::PostInfo>,
    ) -> Self::Result;
}

Single-function utility trait with a blanket impl over TransactionExtension in order to provide transaction dispatching functionality. We avoid implementing this directly on the trait since we never want it to be overriden by the trait implementation.

Required Associated Types

type Origin

The origin type of the transaction.

type Info

The info type.

type Result

The resultant type.

type Val

The Val of the extension.

type Pre

The Pre of the extension.

Required Methods

fn validate_only( &self, origin: Self::Origin, call: &Call, info: &Self::Info, len: usize, ) -> Result<(ValidTransaction, Self::Val, Self::Origin), TransactionValidityError>

Just validate a transaction.

The is basically the same as validate, except that there is no need to supply the bond data.

fn validate_and_prepare( self, origin: Self::Origin, call: &Call, info: &Self::Info, len: usize, ) -> Result<(Self::Pre, Self::Origin), TransactionValidityError>

Validate and prepare a transaction, ready for dispatch.

fn dispatch_transaction( self, origin: Self::Origin, call: Call, info: &Self::Info, len: usize, ) -> Self::Result

Dispatch a transaction with the given base origin and call.

fn test_run( self, origin: Self::Origin, call: &Call, info: &Self::Info, len: usize, substitute: impl FnOnce(Self::Origin) -> DispatchResultWithInfo<<Call as Dispatchable>::PostInfo>, ) -> Self::Result

Do everything which would be done in a dispatch_transaction, but instead of executing the call, execute substitute instead. Since this doesn’t actually dispatch the call, it doesn’t need to consume it and so call can be passed as a reference.

Object Safety

This trait is not object safe.

Implementors

impl<T: TransactionExtension<Call>, Call: Dispatchable + Encode> DispatchTransaction<Call> for T

where <Call as Dispatchable>::RuntimeOrigin: AsTransactionAuthorizedOrigin,

type Origin = <Call as Dispatchable>::RuntimeOrigin

type Info = <Call as Dispatchable>::Info

type Result = Result<Result<<Call as Dispatchable>::PostInfo, DispatchErrorWithPostInfo<<Call as Dispatchable>::PostInfo>>, TransactionValidityError>

type Val = <T as TransactionExtension<Call>>::Val

type Pre = <T as TransactionExtension<Call>>::Pre