Enum InstructionV2 

pub enum InstructionV2 {
    TakeFromWorktop(TakeFromWorktop),
    TakeNonFungiblesFromWorktop(TakeNonFungiblesFromWorktop),
    TakeAllFromWorktop(TakeAllFromWorktop),
    ReturnToWorktop(ReturnToWorktop),
    BurnResource(BurnResource),
    AssertWorktopContainsAny(AssertWorktopContainsAny),
    AssertWorktopContains(AssertWorktopContains),
    AssertWorktopContainsNonFungibles(AssertWorktopContainsNonFungibles),
    AssertWorktopResourcesOnly(AssertWorktopResourcesOnly),
    AssertWorktopResourcesInclude(AssertWorktopResourcesInclude),
    AssertNextCallReturnsOnly(AssertNextCallReturnsOnly),
    AssertNextCallReturnsInclude(AssertNextCallReturnsInclude),
    AssertBucketContents(AssertBucketContents),
    CreateProofFromBucketOfAmount(CreateProofFromBucketOfAmount),
    CreateProofFromBucketOfNonFungibles(CreateProofFromBucketOfNonFungibles),
    CreateProofFromBucketOfAll(CreateProofFromBucketOfAll),
    CreateProofFromAuthZoneOfAmount(CreateProofFromAuthZoneOfAmount),
    CreateProofFromAuthZoneOfNonFungibles(CreateProofFromAuthZoneOfNonFungibles),
    CreateProofFromAuthZoneOfAll(CreateProofFromAuthZoneOfAll),
    CloneProof(CloneProof),
    DropProof(DropProof),
    PushToAuthZone(PushToAuthZone),
    PopFromAuthZone(PopFromAuthZone),
    DropAuthZoneProofs(DropAuthZoneProofs),
    DropAuthZoneRegularProofs(DropAuthZoneRegularProofs),
    DropAuthZoneSignatureProofs(DropAuthZoneSignatureProofs),
    DropNamedProofs(DropNamedProofs),
    DropAllProofs(DropAllProofs),
    CallFunction(CallFunction),
    CallMethod(CallMethod),
    CallRoyaltyMethod(CallRoyaltyMethod),
    CallMetadataMethod(CallMetadataMethod),
    CallRoleAssignmentMethod(CallRoleAssignmentMethod),
    CallDirectVaultMethod(CallDirectVaultMethod),
    AllocateGlobalAddress(AllocateGlobalAddress),
    YieldToParent(YieldToParent),
    YieldToChild(YieldToChild),
    VerifyParent(VerifyParent),
}

Variants

TakeFromWorktop(TakeFromWorktop)

TakeNonFungiblesFromWorktop(TakeNonFungiblesFromWorktop)

TakeAllFromWorktop(TakeAllFromWorktop)

ReturnToWorktop(ReturnToWorktop)

BurnResource(BurnResource)

AssertWorktopContainsAny(AssertWorktopContainsAny)

AssertWorktopContains(AssertWorktopContains)

AssertWorktopContainsNonFungibles(AssertWorktopContainsNonFungibles)

AssertWorktopResourcesOnly(AssertWorktopResourcesOnly)

AssertWorktopResourcesInclude(AssertWorktopResourcesInclude)

AssertNextCallReturnsOnly(AssertNextCallReturnsOnly)

AssertNextCallReturnsInclude(AssertNextCallReturnsInclude)

AssertBucketContents(AssertBucketContents)

CreateProofFromBucketOfAmount(CreateProofFromBucketOfAmount)

CreateProofFromBucketOfNonFungibles(CreateProofFromBucketOfNonFungibles)

CreateProofFromBucketOfAll(CreateProofFromBucketOfAll)

CreateProofFromAuthZoneOfAmount(CreateProofFromAuthZoneOfAmount)

CreateProofFromAuthZoneOfNonFungibles(CreateProofFromAuthZoneOfNonFungibles)

CreateProofFromAuthZoneOfAll(CreateProofFromAuthZoneOfAll)

CloneProof(CloneProof)

DropProof(DropProof)

PushToAuthZone(PushToAuthZone)

PopFromAuthZone(PopFromAuthZone)

DropAuthZoneProofs(DropAuthZoneProofs)

DropAuthZoneRegularProofs(DropAuthZoneRegularProofs)

DropAuthZoneSignatureProofs(DropAuthZoneSignatureProofs)

DropNamedProofs(DropNamedProofs)

DropAllProofs(DropAllProofs)

CallFunction(CallFunction)

CallMethod(CallMethod)

CallRoyaltyMethod(CallRoyaltyMethod)

CallMetadataMethod(CallMetadataMethod)

CallRoleAssignmentMethod(CallRoleAssignmentMethod)

CallDirectVaultMethod(CallDirectVaultMethod)

AllocateGlobalAddress(AllocateGlobalAddress)

YieldToParent(YieldToParent)

YieldToChild(YieldToChild)

VerifyParent(VerifyParent)

Trait Implementations

impl Categorize<ManifestCustomValueKind> for InstructionV2

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Clone for InstructionV2

fn clone(&self) -> InstructionV2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InstructionV2

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

Formats the value using the given formatter.

impl<D> Decode<ManifestCustomValueKind, D> for InstructionV2

where D: Decoder<ManifestCustomValueKind>,

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ManifestCustomValueKind>, ) -> Result<InstructionV2, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl Describe<ScryptoCustomTypeKind> for InstructionV2

const TYPE_ID: RustTypeId

The TYPE_ID should give a unique identifier for its SBOR schema type. An SBOR schema type capture details about the SBOR payload, how it should be interpreted, validated and displayed.

fn type_data() -> TypeData<ScryptoCustomTypeKind, RustTypeId>

Returns the local schema for the given type.

fn add_all_dependencies(aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>)

For each type referenced in get_local_type_data, we need to ensure that the type and all of its own references get added to the aggregator.

impl<E> Encode<ManifestCustomValueKind, E> for InstructionV2

where E: Encoder<ManifestCustomValueKind>,

fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR value’s kind to the encoder

fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR body of the type to the encoder.

impl From<InstructionV1> for InstructionV2

fn from(any_v1_instruction: InstructionV1) -> InstructionV2

Converts to this type from the input type.

impl<T> From<T> for InstructionV2

where T: SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>,

fn from(value: T) -> InstructionV2

Converts to this type from the input type.

impl ManifestInstructionSet for InstructionV2

fn map_ref<M>(&self, mapper: M) -> <M as InstructionRefMapper>::Output<'_>

where M: InstructionRefMapper,

fn map_self<M>(self, mapper: M) -> <M as OwnedInstructionMapper>::Output

where M: OwnedInstructionMapper,

fn decompile( &self, context: &mut DecompilationContext<'_>, ) -> Result<DecompiledInstruction, DecompileError>

fn effect(&self) -> ManifestInstructionEffect<'_>

fn into_any(self) -> InstructionV2

fn try_convert<T>(self) -> Result<T, <InstructionV2 as TryInto<T>>::Error>

where InstructionV2: TryInto<T>,

impl PartialEq for InstructionV2

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SborEnum<ManifestCustomValueKind> for InstructionV2

fn get_discriminator(&self) -> u8

fn get_length(&self) -> usize

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AllocateGlobalAddress

const DISCRIMINATOR: u8 = 81u8

const IS_FLATTENED: bool = true

type VariantFields = AllocateGlobalAddress

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AllocateGlobalAddress

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#43}::OwnedVariant::{constant#0}, <AllocateGlobalAddress as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#43}::BorrowedVariant::{constant#0}, <AllocateGlobalAddress as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AllocateGlobalAddress as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AllocateGlobalAddress

fn as_variant_fields_ref( &self, ) -> <AllocateGlobalAddress as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertBucketContents

const DISCRIMINATOR: u8 = 12u8

const IS_FLATTENED: bool = true

type VariantFields = AssertBucketContents

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertBucketContents

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#21}::OwnedVariant::{constant#0}, <AssertBucketContents as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#21}::BorrowedVariant::{constant#0}, <AssertBucketContents as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertBucketContents as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertBucketContents

fn as_variant_fields_ref( &self, ) -> <AssertBucketContents as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertNextCallReturnsInclude

const DISCRIMINATOR: u8 = 11u8

const IS_FLATTENED: bool = true

type VariantFields = AssertNextCallReturnsInclude

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertNextCallReturnsInclude

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#20}::OwnedVariant::{constant#0}, <AssertNextCallReturnsInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#20}::BorrowedVariant::{constant#0}, <AssertNextCallReturnsInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertNextCallReturnsInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertNextCallReturnsInclude

fn as_variant_fields_ref( &self, ) -> <AssertNextCallReturnsInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertNextCallReturnsOnly

const DISCRIMINATOR: u8 = 10u8

const IS_FLATTENED: bool = true

type VariantFields = AssertNextCallReturnsOnly

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertNextCallReturnsOnly

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#19}::OwnedVariant::{constant#0}, <AssertNextCallReturnsOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#19}::BorrowedVariant::{constant#0}, <AssertNextCallReturnsOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertNextCallReturnsOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertNextCallReturnsOnly

fn as_variant_fields_ref( &self, ) -> <AssertNextCallReturnsOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopContains

const DISCRIMINATOR: u8 = 4u8

const IS_FLATTENED: bool = true

type VariantFields = AssertWorktopContains

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertWorktopContains

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#15}::OwnedVariant::{constant#0}, <AssertWorktopContains as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#15}::BorrowedVariant::{constant#0}, <AssertWorktopContains as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertWorktopContains as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertWorktopContains

fn as_variant_fields_ref( &self, ) -> <AssertWorktopContains as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopContainsAny

const DISCRIMINATOR: u8 = 6u8

const IS_FLATTENED: bool = true

type VariantFields = AssertWorktopContainsAny

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertWorktopContainsAny

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#14}::OwnedVariant::{constant#0}, <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#14}::BorrowedVariant::{constant#0}, <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertWorktopContainsAny

fn as_variant_fields_ref( &self, ) -> <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopContainsNonFungibles

const DISCRIMINATOR: u8 = 5u8

const IS_FLATTENED: bool = true

type VariantFields = AssertWorktopContainsNonFungibles

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertWorktopContainsNonFungibles

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#16}::OwnedVariant::{constant#0}, <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#16}::BorrowedVariant::{constant#0}, <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertWorktopContainsNonFungibles

fn as_variant_fields_ref( &self, ) -> <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopResourcesInclude

const DISCRIMINATOR: u8 = 9u8

const IS_FLATTENED: bool = true

type VariantFields = AssertWorktopResourcesInclude

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertWorktopResourcesInclude

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#18}::OwnedVariant::{constant#0}, <AssertWorktopResourcesInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#18}::BorrowedVariant::{constant#0}, <AssertWorktopResourcesInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertWorktopResourcesInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertWorktopResourcesInclude

fn as_variant_fields_ref( &self, ) -> <AssertWorktopResourcesInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopResourcesOnly

const DISCRIMINATOR: u8 = 8u8

const IS_FLATTENED: bool = true

type VariantFields = AssertWorktopResourcesOnly

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a AssertWorktopResourcesOnly

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#17}::OwnedVariant::{constant#0}, <AssertWorktopResourcesOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#17}::BorrowedVariant::{constant#0}, <AssertWorktopResourcesOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <AssertWorktopResourcesOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> AssertWorktopResourcesOnly

fn as_variant_fields_ref( &self, ) -> <AssertWorktopResourcesOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for BurnResource

const DISCRIMINATOR: u8 = 36u8

const IS_FLATTENED: bool = true

type VariantFields = BurnResource

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a BurnResource

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#13}::OwnedVariant::{constant#0}, <BurnResource as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#13}::BorrowedVariant::{constant#0}, <BurnResource as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <BurnResource as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> BurnResource

fn as_variant_fields_ref( &self, ) -> <BurnResource as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallDirectVaultMethod

const DISCRIMINATOR: u8 = 69u8

const IS_FLATTENED: bool = true

type VariantFields = CallDirectVaultMethod

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CallDirectVaultMethod

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#42}::OwnedVariant::{constant#0}, <CallDirectVaultMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#42}::BorrowedVariant::{constant#0}, <CallDirectVaultMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CallDirectVaultMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CallDirectVaultMethod

fn as_variant_fields_ref( &self, ) -> <CallDirectVaultMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallFunction

const DISCRIMINATOR: u8 = 64u8

const IS_FLATTENED: bool = true

type VariantFields = CallFunction

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CallFunction

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#37}::OwnedVariant::{constant#0}, <CallFunction as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#37}::BorrowedVariant::{constant#0}, <CallFunction as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CallFunction as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CallFunction

fn as_variant_fields_ref( &self, ) -> <CallFunction as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallMetadataMethod

const DISCRIMINATOR: u8 = 67u8

const IS_FLATTENED: bool = true

type VariantFields = CallMetadataMethod

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CallMetadataMethod

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#40}::OwnedVariant::{constant#0}, <CallMetadataMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#40}::BorrowedVariant::{constant#0}, <CallMetadataMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CallMetadataMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CallMetadataMethod

fn as_variant_fields_ref( &self, ) -> <CallMetadataMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallMethod

const DISCRIMINATOR: u8 = 65u8

const IS_FLATTENED: bool = true

type VariantFields = CallMethod

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CallMethod

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#38}::OwnedVariant::{constant#0}, <CallMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#38}::BorrowedVariant::{constant#0}, <CallMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CallMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CallMethod

fn as_variant_fields_ref( &self, ) -> <CallMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallRoleAssignmentMethod

const DISCRIMINATOR: u8 = 68u8

const IS_FLATTENED: bool = true

type VariantFields = CallRoleAssignmentMethod

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CallRoleAssignmentMethod

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#41}::OwnedVariant::{constant#0}, <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#41}::BorrowedVariant::{constant#0}, <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CallRoleAssignmentMethod

fn as_variant_fields_ref( &self, ) -> <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallRoyaltyMethod

const DISCRIMINATOR: u8 = 66u8

const IS_FLATTENED: bool = true

type VariantFields = CallRoyaltyMethod

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CallRoyaltyMethod

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#39}::OwnedVariant::{constant#0}, <CallRoyaltyMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#39}::BorrowedVariant::{constant#0}, <CallRoyaltyMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CallRoyaltyMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CallRoyaltyMethod

fn as_variant_fields_ref( &self, ) -> <CallRoyaltyMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CloneProof

const DISCRIMINATOR: u8 = 48u8

const IS_FLATTENED: bool = true

type VariantFields = CloneProof

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CloneProof

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#28}::OwnedVariant::{constant#0}, <CloneProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#28}::BorrowedVariant::{constant#0}, <CloneProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CloneProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CloneProof

fn as_variant_fields_ref( &self, ) -> <CloneProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromAuthZoneOfAll

const DISCRIMINATOR: u8 = 22u8

const IS_FLATTENED: bool = true

type VariantFields = CreateProofFromAuthZoneOfAll

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfAll

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#27}::OwnedVariant::{constant#0}, <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#27}::BorrowedVariant::{constant#0}, <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CreateProofFromAuthZoneOfAll

fn as_variant_fields_ref( &self, ) -> <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromAuthZoneOfAmount

const DISCRIMINATOR: u8 = 20u8

const IS_FLATTENED: bool = true

type VariantFields = CreateProofFromAuthZoneOfAmount

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfAmount

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#25}::OwnedVariant::{constant#0}, <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#25}::BorrowedVariant::{constant#0}, <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CreateProofFromAuthZoneOfAmount

fn as_variant_fields_ref( &self, ) -> <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromAuthZoneOfNonFungibles

const DISCRIMINATOR: u8 = 21u8

const IS_FLATTENED: bool = true

type VariantFields = CreateProofFromAuthZoneOfNonFungibles

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfNonFungibles

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#26}::OwnedVariant::{constant#0}, <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#26}::BorrowedVariant::{constant#0}, <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CreateProofFromAuthZoneOfNonFungibles

fn as_variant_fields_ref( &self, ) -> <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromBucketOfAll

const DISCRIMINATOR: u8 = 35u8

const IS_FLATTENED: bool = true

type VariantFields = CreateProofFromBucketOfAll

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfAll

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#24}::OwnedVariant::{constant#0}, <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#24}::BorrowedVariant::{constant#0}, <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CreateProofFromBucketOfAll

fn as_variant_fields_ref( &self, ) -> <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromBucketOfAmount

const DISCRIMINATOR: u8 = 33u8

const IS_FLATTENED: bool = true

type VariantFields = CreateProofFromBucketOfAmount

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfAmount

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#22}::OwnedVariant::{constant#0}, <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#22}::BorrowedVariant::{constant#0}, <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CreateProofFromBucketOfAmount

fn as_variant_fields_ref( &self, ) -> <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromBucketOfNonFungibles

const DISCRIMINATOR: u8 = 34u8

const IS_FLATTENED: bool = true

type VariantFields = CreateProofFromBucketOfNonFungibles

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfNonFungibles

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#23}::OwnedVariant::{constant#0}, <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#23}::BorrowedVariant::{constant#0}, <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> CreateProofFromBucketOfNonFungibles

fn as_variant_fields_ref( &self, ) -> <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAllProofs

const DISCRIMINATOR: u8 = 80u8

const IS_FLATTENED: bool = true

type VariantFields = DropAllProofs

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a DropAllProofs

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#36}::OwnedVariant::{constant#0}, <DropAllProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#36}::BorrowedVariant::{constant#0}, <DropAllProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <DropAllProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> DropAllProofs

fn as_variant_fields_ref( &self, ) -> <DropAllProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAuthZoneProofs

const DISCRIMINATOR: u8 = 18u8

const IS_FLATTENED: bool = true

type VariantFields = DropAuthZoneProofs

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a DropAuthZoneProofs

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#32}::OwnedVariant::{constant#0}, <DropAuthZoneProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#32}::BorrowedVariant::{constant#0}, <DropAuthZoneProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <DropAuthZoneProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> DropAuthZoneProofs

fn as_variant_fields_ref( &self, ) -> <DropAuthZoneProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAuthZoneRegularProofs

const DISCRIMINATOR: u8 = 19u8

const IS_FLATTENED: bool = true

type VariantFields = DropAuthZoneRegularProofs

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a DropAuthZoneRegularProofs

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#33}::OwnedVariant::{constant#0}, <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#33}::BorrowedVariant::{constant#0}, <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> DropAuthZoneRegularProofs

fn as_variant_fields_ref( &self, ) -> <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAuthZoneSignatureProofs

const DISCRIMINATOR: u8 = 23u8

const IS_FLATTENED: bool = true

type VariantFields = DropAuthZoneSignatureProofs

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a DropAuthZoneSignatureProofs

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#34}::OwnedVariant::{constant#0}, <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#34}::BorrowedVariant::{constant#0}, <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> DropAuthZoneSignatureProofs

fn as_variant_fields_ref( &self, ) -> <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropNamedProofs

const DISCRIMINATOR: u8 = 82u8

const IS_FLATTENED: bool = true

type VariantFields = DropNamedProofs

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a DropNamedProofs

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#35}::OwnedVariant::{constant#0}, <DropNamedProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#35}::BorrowedVariant::{constant#0}, <DropNamedProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <DropNamedProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> DropNamedProofs

fn as_variant_fields_ref( &self, ) -> <DropNamedProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropProof

const DISCRIMINATOR: u8 = 49u8

const IS_FLATTENED: bool = true

type VariantFields = DropProof

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a DropProof

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#29}::OwnedVariant::{constant#0}, <DropProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#29}::BorrowedVariant::{constant#0}, <DropProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <DropProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> DropProof

fn as_variant_fields_ref( &self, ) -> <DropProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for PopFromAuthZone

const DISCRIMINATOR: u8 = 16u8

const IS_FLATTENED: bool = true

type VariantFields = PopFromAuthZone

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a PopFromAuthZone

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#31}::OwnedVariant::{constant#0}, <PopFromAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#31}::BorrowedVariant::{constant#0}, <PopFromAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <PopFromAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> PopFromAuthZone

fn as_variant_fields_ref( &self, ) -> <PopFromAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for PushToAuthZone

const DISCRIMINATOR: u8 = 17u8

const IS_FLATTENED: bool = true

type VariantFields = PushToAuthZone

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a PushToAuthZone

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#30}::OwnedVariant::{constant#0}, <PushToAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#30}::BorrowedVariant::{constant#0}, <PushToAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <PushToAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> PushToAuthZone

fn as_variant_fields_ref( &self, ) -> <PushToAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for ReturnToWorktop

const DISCRIMINATOR: u8 = 3u8

const IS_FLATTENED: bool = true

type VariantFields = ReturnToWorktop

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a ReturnToWorktop

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#12}::OwnedVariant::{constant#0}, <ReturnToWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#12}::BorrowedVariant::{constant#0}, <ReturnToWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <ReturnToWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> ReturnToWorktop

fn as_variant_fields_ref( &self, ) -> <ReturnToWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for TakeAllFromWorktop

const DISCRIMINATOR: u8 = 2u8

const IS_FLATTENED: bool = true

type VariantFields = TakeAllFromWorktop

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a TakeAllFromWorktop

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#11}::OwnedVariant::{constant#0}, <TakeAllFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#11}::BorrowedVariant::{constant#0}, <TakeAllFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <TakeAllFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> TakeAllFromWorktop

fn as_variant_fields_ref( &self, ) -> <TakeAllFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for TakeFromWorktop

const DISCRIMINATOR: u8 = 0u8

const IS_FLATTENED: bool = true

type VariantFields = TakeFromWorktop

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a TakeFromWorktop

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#9}::OwnedVariant::{constant#0}, <TakeFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#9}::BorrowedVariant::{constant#0}, <TakeFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <TakeFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> TakeFromWorktop

fn as_variant_fields_ref( &self, ) -> <TakeFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for TakeNonFungiblesFromWorktop

const DISCRIMINATOR: u8 = 1u8

const IS_FLATTENED: bool = true

type VariantFields = TakeNonFungiblesFromWorktop

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a TakeNonFungiblesFromWorktop

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#10}::OwnedVariant::{constant#0}, <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#10}::BorrowedVariant::{constant#0}, <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> TakeNonFungiblesFromWorktop

fn as_variant_fields_ref( &self, ) -> <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for VerifyParent

const DISCRIMINATOR: u8 = 98u8

const IS_FLATTENED: bool = true

type VariantFields = VerifyParent

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a VerifyParent

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#46}::OwnedVariant::{constant#0}, <VerifyParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#46}::BorrowedVariant::{constant#0}, <VerifyParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <VerifyParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> VerifyParent

fn as_variant_fields_ref( &self, ) -> <VerifyParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for YieldToChild

const DISCRIMINATOR: u8 = 97u8

const IS_FLATTENED: bool = true

type VariantFields = YieldToChild

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a YieldToChild

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#45}::OwnedVariant::{constant#0}, <YieldToChild as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#45}::BorrowedVariant::{constant#0}, <YieldToChild as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <YieldToChild as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> YieldToChild

fn as_variant_fields_ref( &self, ) -> <YieldToChild as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for YieldToParent

const DISCRIMINATOR: u8 = 96u8

const IS_FLATTENED: bool = true

type VariantFields = YieldToParent

VariantFields is either Self if IS_FLATTENED else is (Self,)

type VariantFieldsRef<'a> = &'a YieldToParent

VariantFieldsRef is either &Self if IS_FLATTENED else is (&Self,)

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#44}::OwnedVariant::{constant#0}, <YieldToParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

This should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, Self::VariantFields>

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v2::instruction_v2::{impl#44}::BorrowedVariant::{constant#0}, <YieldToParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

Should always be SborFixedEnumVariant<{ [DISCRIMINATOR] as u8 }, &'a Self::VariantFields>

fn from_variant_fields( variant_fields: <YieldToParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields, ) -> YieldToParent

fn as_variant_fields_ref( &self, ) -> <YieldToParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'_>

fn into_enum(self) -> InstructionV2

fn as_encodable_variant<'a>(&'a self) -> Self::BorrowedVariant<'a>

Can be used to encode the type as a variant under TEnum, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self

where Self: Sized,

Can be used to decode the type from an encoded variant, like this: T::from_decoded_variant(decoder.decode()?).

impl TryFrom<InstructionV2> for InstructionV1

type Error = ()

The type returned in the event of a conversion error.

fn try_from( value: InstructionV2, ) -> Result<InstructionV1, <InstructionV1 as TryFrom<InstructionV2>>::Error>

Performs the conversion.

impl TxnInstruction for InstructionV2

fn execute<Y, L>( self, worktop: &mut Worktop, objects: &mut IntentProcessorObjects<'_>, api: &mut Y, ) -> Result<(InstructionOutput, Option<MultiThreadResult>), RuntimeError>

where Y: SystemApi<RuntimeError> + KernelNodeApi + KernelSubstateApi<L>, L: Default,

impl CheckedBackwardsCompatibleSchema<ScryptoCustomSchema> for InstructionV2

impl Eq for InstructionV2

impl StructuralPartialEq for InstructionV2