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

Formats the value using the given formatter.

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

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ManifestCustomValueKind>, ) -> Result<Self, 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: Encoder<ManifestCustomValueKind>> Encode<ManifestCustomValueKind, E> for InstructionV2

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<T: SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>> From<T> for InstructionV2

fn from(value: T) -> Self

Converts to this type from the input type.

impl ManifestInstructionSet for InstructionV2

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

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

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

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

fn into_any(self) -> AnyInstruction

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

where AnyInstruction: 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<ManifestSbor, <AllocateGlobalAddress as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AllocateGlobalAddress as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertBucketContents as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertBucketContents as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertNextCallReturnsInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertNextCallReturnsInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertNextCallReturnsOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertNextCallReturnsOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertWorktopContains as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertWorktopContains as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertWorktopResourcesInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertWorktopResourcesInclude as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <AssertWorktopResourcesOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <AssertWorktopResourcesOnly as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <BurnResource as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <BurnResource as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CallDirectVaultMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CallDirectVaultMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CallFunction as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CallFunction as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CallMetadataMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CallMetadataMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CallMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CallMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CallRoyaltyMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CallRoyaltyMethod as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CloneProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CloneProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <DropAllProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <DropAllProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <DropAuthZoneProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <DropAuthZoneProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <DropNamedProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <DropNamedProofs as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <DropProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <DropProof as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <PopFromAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <PopFromAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <PushToAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <PushToAuthZone as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <ReturnToWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <ReturnToWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <TakeAllFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <TakeAllFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <TakeFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <TakeFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <VerifyParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <VerifyParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <YieldToChild as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <YieldToChild as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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<ManifestSbor, <YieldToParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFields>

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

type BorrowedVariant<'a> = SborFixedEnumVariant<ManifestSbor, <YieldToParent as SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

fn from_variant_fields(variant_fields: Self::VariantFields) -> Self

fn as_variant_fields_ref(&self) -> Self::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: AnyInstruction) -> Result<Self, Self::Error>

Performs the conversion.

impl CheckedBackwardsCompatibleSchema<ScryptoCustomSchema> for InstructionV2

impl Eq for InstructionV2

impl StructuralPartialEq for InstructionV2