PreparedTestTransaction

radix_transactions::model

Enum PreparedTestTransaction

pub enum PreparedTestTransaction {
    V1(PreparedTestIntent),
    V2 {
        root_intent: PreparedTestIntent,
        subintents: Vec<PreparedTestIntent>,
    },
}

Variants§

V1(PreparedTestIntent)

V2

Fields

§root_intent: PreparedTestIntent

§subintents: Vec<PreparedTestIntent>

Implementations§

impl PreparedTestTransaction

pub fn into_unvalidated_executable(self) -> ExecutableTransaction

Trait Implementations§

impl IntoExecutable for PreparedTestTransaction

type Error = Infallible

fn into_executable( self, _validator: &TransactionValidator, ) -> Result<ExecutableTransaction, Self::Error>

fn into_executable_unwrap(self) -> ExecutableTransaction
where Self: Sized,

For use in tests as a quick mechanism to get an executable. Validates with a network-independent validator, using the latest settings.

Auto Trait Implementations§

impl Freeze for PreparedTestTransaction

impl RefUnwindSafe for PreparedTestTransaction

impl Send for PreparedTestTransaction

impl Sync for PreparedTestTransaction

impl Unpin for PreparedTestTransaction

impl UnwindSafe for PreparedTestTransaction

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<U> As for U

fn as_<T>(self) -> T
where T: CastFrom<U>,

Casts self to type T. The semantics of numeric casting with the as operator are followed, so <T as As>::as_::<U> can be used in the same way as T as U for numeric conversions. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T, U> ContextualTryInto<U> for T
where U: ContextualTryFrom<T>,

type Error = <U as ContextualTryFrom<T>>::Error

type Context = <U as ContextualTryFrom<T>>::Context

fn contextual_try_into( self, context: &<U as ContextualTryFrom<T>>::Context, ) -> Result<U, <U as ContextualTryFrom<T>>::Error>

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

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

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<X, Y> LabelledResolve<Y> for X
where Y: LabelledResolveFrom<X>,

fn labelled_resolve( self, resolver: &impl LabelResolver<<Y as LabelledResolvable>::ResolverOutput>, ) -> Y

impl<X, Y> Resolve<Y> for X
where Y: ResolveFrom<X>,

fn resolve(self) -> Y

impl<T> Same for T

type Output = T

Should always be Self

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

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.