Enum ManifestCustomValueKind

Source

pub enum ManifestCustomValueKind {
    Address,
    Bucket,
    Proof,
    Expression,
    Blob,
    Decimal,
    PreciseDecimal,
    NonFungibleLocalId,
    AddressReservation,
}

Variants§

§

AddressReservation

fn clone(&self) -> ManifestCustomValueKind

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

type VariantFields = FlashTransactionV1

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

Source §

type VariantFieldsRef<'a> = &'a FlashTransactionV1

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#20}::OwnedVariant::{constant#0}, <FlashTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#20}::BorrowedVariant::{constant#0}, <FlashTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <FlashTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> FlashTransactionV1

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for IntentV1

Source §

const DISCRIMINATOR: u8 = 1u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = IntentV1

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

Source §

type VariantFieldsRef<'a> = &'a IntentV1

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#14}::OwnedVariant::{constant#0}, <IntentV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#14}::BorrowedVariant::{constant#0}, <IntentV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <IntentV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> IntentV1

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for LedgerTransaction

Source §

const DISCRIMINATOR: u8 = 7u8

Source §

const IS_FLATTENED: bool = false

Source §

type VariantFields = (LedgerTransaction,)

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

Source §

type VariantFieldsRef<'a> = (&'a LedgerTransaction,)

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#19}::OwnedVariant::{constant#0}, <LedgerTransaction as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#19}::BorrowedVariant::{constant#0}, <LedgerTransaction as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <LedgerTransaction as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> LedgerTransaction

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for NotarizedTransactionV1

Source §

const DISCRIMINATOR: u8 = 3u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = NotarizedTransactionV1

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

Source §

type VariantFieldsRef<'a> = &'a NotarizedTransactionV1

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#16}::OwnedVariant::{constant#0}, <NotarizedTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#16}::BorrowedVariant::{constant#0}, <NotarizedTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <NotarizedTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> NotarizedTransactionV1

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for NotarizedTransactionV2

Source §

const DISCRIMINATOR: u8 = 12u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = NotarizedTransactionV2

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

Source §

type VariantFieldsRef<'a> = &'a NotarizedTransactionV2

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#24}::OwnedVariant::{constant#0}, <NotarizedTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#24}::BorrowedVariant::{constant#0}, <NotarizedTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <NotarizedTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> NotarizedTransactionV2

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for PartialTransactionV2

Source §

const DISCRIMINATOR: u8 = 13u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = PartialTransactionV2

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

Source §

type VariantFieldsRef<'a> = &'a PartialTransactionV2

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#25}::OwnedVariant::{constant#0}, <PartialTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#25}::BorrowedVariant::{constant#0}, <PartialTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <PartialTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> PartialTransactionV2

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for PreviewTransactionV2

Source §

const DISCRIMINATOR: u8 = 15u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = PreviewTransactionV2

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

Source §

type VariantFieldsRef<'a> = &'a PreviewTransactionV2

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#27}::OwnedVariant::{constant#0}, <PreviewTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#27}::BorrowedVariant::{constant#0}, <PreviewTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <PreviewTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> PreviewTransactionV2

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for RoundUpdateTransactionV1

Source §

const DISCRIMINATOR: u8 = 5u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = RoundUpdateTransactionV1

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

Source §

type VariantFieldsRef<'a> = &'a RoundUpdateTransactionV1

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#18}::OwnedVariant::{constant#0}, <RoundUpdateTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#18}::BorrowedVariant::{constant#0}, <RoundUpdateTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <RoundUpdateTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> RoundUpdateTransactionV1

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SignedIntentV1

Source §

const DISCRIMINATOR: u8 = 2u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = SignedIntentV1

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

Source §

type VariantFieldsRef<'a> = &'a SignedIntentV1

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#15}::OwnedVariant::{constant#0}, <SignedIntentV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#15}::BorrowedVariant::{constant#0}, <SignedIntentV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <SignedIntentV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> SignedIntentV1

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SignedPartialTransactionV2

Source §

const DISCRIMINATOR: u8 = 14u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = SignedPartialTransactionV2

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

Source §

type VariantFieldsRef<'a> = &'a SignedPartialTransactionV2

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#26}::OwnedVariant::{constant#0}, <SignedPartialTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#26}::BorrowedVariant::{constant#0}, <SignedPartialTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <SignedPartialTransactionV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> SignedPartialTransactionV2

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SignedTransactionIntentV2

Source §

const DISCRIMINATOR: u8 = 10u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = SignedTransactionIntentV2

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

Source §

type VariantFieldsRef<'a> = &'a SignedTransactionIntentV2

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#22}::OwnedVariant::{constant#0}, <SignedTransactionIntentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#22}::BorrowedVariant::{constant#0}, <SignedTransactionIntentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <SignedTransactionIntentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> SignedTransactionIntentV2

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SubintentV2

Source §

const DISCRIMINATOR: u8 = 11u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = SubintentV2

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

Source §

type VariantFieldsRef<'a> = &'a SubintentV2

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#23}::OwnedVariant::{constant#0}, <SubintentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#23}::BorrowedVariant::{constant#0}, <SubintentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <SubintentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> SubintentV2

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SystemTransactionV1

Source §

const DISCRIMINATOR: u8 = 4u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = SystemTransactionV1

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

Source §

type VariantFieldsRef<'a> = &'a SystemTransactionV1

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#17}::OwnedVariant::{constant#0}, <SystemTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#17}::BorrowedVariant::{constant#0}, <SystemTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <SystemTransactionV1 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> SystemTransactionV1

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for TransactionIntentV2

Source §

const DISCRIMINATOR: u8 = 9u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = TransactionIntentV2

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

Source §

type VariantFieldsRef<'a> = &'a TransactionIntentV2

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#21}::OwnedVariant::{constant#0}, <TransactionIntentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::any_transaction::{impl#21}::BorrowedVariant::{constant#0}, <TransactionIntentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

fn from_variant_fields( variant_fields: <TransactionIntentV2 as SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind>>::VariantFields, ) -> TransactionIntentV2

Source §

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

Source §

fn into_enum(self) -> AnyTransaction

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for AllocateGlobalAddress

Source §

const DISCRIMINATOR: u8 = 81u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AllocateGlobalAddress

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

Source §

type VariantFieldsRef<'a> = &'a AllocateGlobalAddress

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#40}::OwnedVariant::{constant#0}, <AllocateGlobalAddress as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#40}::BorrowedVariant::{constant#0}, <AllocateGlobalAddress as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for AssertWorktopContains

Source §

const DISCRIMINATOR: u8 = 4u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopContains

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopContains

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#17}::OwnedVariant::{constant#0}, <AssertWorktopContains as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#17}::BorrowedVariant::{constant#0}, <AssertWorktopContains as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for AssertWorktopContainsAny

Source §

const DISCRIMINATOR: u8 = 6u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopContainsAny

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopContainsAny

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#16}::OwnedVariant::{constant#0}, <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#16}::BorrowedVariant::{constant#0}, <AssertWorktopContainsAny as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for AssertWorktopContainsNonFungibles

Source §

const DISCRIMINATOR: u8 = 5u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopContainsNonFungibles

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopContainsNonFungibles

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#18}::OwnedVariant::{constant#0}, <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#18}::BorrowedVariant::{constant#0}, <AssertWorktopContainsNonFungibles as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for BurnResource

Source §

const DISCRIMINATOR: u8 = 36u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = BurnResource

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

Source §

type VariantFieldsRef<'a> = &'a BurnResource

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#15}::OwnedVariant::{constant#0}, <BurnResource as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#15}::BorrowedVariant::{constant#0}, <BurnResource as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CallDirectVaultMethod

Source §

const DISCRIMINATOR: u8 = 69u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallDirectVaultMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallDirectVaultMethod

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#39}::OwnedVariant::{constant#0}, <CallDirectVaultMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#39}::BorrowedVariant::{constant#0}, <CallDirectVaultMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CallFunction

Source §

const DISCRIMINATOR: u8 = 64u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallFunction

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

Source §

type VariantFieldsRef<'a> = &'a CallFunction

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#34}::OwnedVariant::{constant#0}, <CallFunction as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#34}::BorrowedVariant::{constant#0}, <CallFunction as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CallMetadataMethod

Source §

const DISCRIMINATOR: u8 = 67u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallMetadataMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallMetadataMethod

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#37}::OwnedVariant::{constant#0}, <CallMetadataMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#37}::BorrowedVariant::{constant#0}, <CallMetadataMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CallMethod

Source §

const DISCRIMINATOR: u8 = 65u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallMethod

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#35}::OwnedVariant::{constant#0}, <CallMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#35}::BorrowedVariant::{constant#0}, <CallMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CallRoleAssignmentMethod

Source §

const DISCRIMINATOR: u8 = 68u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallRoleAssignmentMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallRoleAssignmentMethod

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#38}::OwnedVariant::{constant#0}, <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#38}::BorrowedVariant::{constant#0}, <CallRoleAssignmentMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CallRoyaltyMethod

Source §

const DISCRIMINATOR: u8 = 66u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallRoyaltyMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallRoyaltyMethod

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#36}::OwnedVariant::{constant#0}, <CallRoyaltyMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#36}::BorrowedVariant::{constant#0}, <CallRoyaltyMethod as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CloneProof

Source §

const DISCRIMINATOR: u8 = 48u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CloneProof

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

Source §

type VariantFieldsRef<'a> = &'a CloneProof

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#25}::OwnedVariant::{constant#0}, <CloneProof as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#25}::BorrowedVariant::{constant#0}, <CloneProof as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CreateProofFromAuthZoneOfAll

Source §

const DISCRIMINATOR: u8 = 22u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromAuthZoneOfAll

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfAll

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#24}::OwnedVariant::{constant#0}, <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#24}::BorrowedVariant::{constant#0}, <CreateProofFromAuthZoneOfAll as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CreateProofFromAuthZoneOfAmount

Source §

const DISCRIMINATOR: u8 = 20u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromAuthZoneOfAmount

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfAmount

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#22}::OwnedVariant::{constant#0}, <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#22}::BorrowedVariant::{constant#0}, <CreateProofFromAuthZoneOfAmount as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CreateProofFromAuthZoneOfNonFungibles

Source §

const DISCRIMINATOR: u8 = 21u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromAuthZoneOfNonFungibles

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfNonFungibles

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#23}::OwnedVariant::{constant#0}, <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#23}::BorrowedVariant::{constant#0}, <CreateProofFromAuthZoneOfNonFungibles as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CreateProofFromBucketOfAll

Source §

const DISCRIMINATOR: u8 = 35u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromBucketOfAll

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfAll

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#21}::OwnedVariant::{constant#0}, <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#21}::BorrowedVariant::{constant#0}, <CreateProofFromBucketOfAll as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CreateProofFromBucketOfAmount

Source §

const DISCRIMINATOR: u8 = 33u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromBucketOfAmount

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfAmount

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#19}::OwnedVariant::{constant#0}, <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#19}::BorrowedVariant::{constant#0}, <CreateProofFromBucketOfAmount as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for CreateProofFromBucketOfNonFungibles

Source §

const DISCRIMINATOR: u8 = 34u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromBucketOfNonFungibles

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfNonFungibles

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#20}::OwnedVariant::{constant#0}, <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#20}::BorrowedVariant::{constant#0}, <CreateProofFromBucketOfNonFungibles as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for DropAllProofs

Source §

const DISCRIMINATOR: u8 = 80u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAllProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAllProofs

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#33}::OwnedVariant::{constant#0}, <DropAllProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#33}::BorrowedVariant::{constant#0}, <DropAllProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for DropAuthZoneProofs

Source §

const DISCRIMINATOR: u8 = 18u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAuthZoneProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAuthZoneProofs

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#29}::OwnedVariant::{constant#0}, <DropAuthZoneProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#29}::BorrowedVariant::{constant#0}, <DropAuthZoneProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for DropAuthZoneRegularProofs

Source §

const DISCRIMINATOR: u8 = 19u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAuthZoneRegularProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAuthZoneRegularProofs

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#30}::OwnedVariant::{constant#0}, <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#30}::BorrowedVariant::{constant#0}, <DropAuthZoneRegularProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for DropAuthZoneSignatureProofs

Source §

const DISCRIMINATOR: u8 = 23u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAuthZoneSignatureProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAuthZoneSignatureProofs

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#31}::OwnedVariant::{constant#0}, <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#31}::BorrowedVariant::{constant#0}, <DropAuthZoneSignatureProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for DropNamedProofs

Source §

const DISCRIMINATOR: u8 = 82u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropNamedProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropNamedProofs

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#32}::OwnedVariant::{constant#0}, <DropNamedProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#32}::BorrowedVariant::{constant#0}, <DropNamedProofs as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for DropProof

Source §

const DISCRIMINATOR: u8 = 49u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropProof

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

Source §

type VariantFieldsRef<'a> = &'a DropProof

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#26}::OwnedVariant::{constant#0}, <DropProof as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#26}::BorrowedVariant::{constant#0}, <DropProof as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for PopFromAuthZone

Source §

const DISCRIMINATOR: u8 = 16u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = PopFromAuthZone

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

Source §

type VariantFieldsRef<'a> = &'a PopFromAuthZone

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#28}::OwnedVariant::{constant#0}, <PopFromAuthZone as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#28}::BorrowedVariant::{constant#0}, <PopFromAuthZone as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for PushToAuthZone

Source §

const DISCRIMINATOR: u8 = 17u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = PushToAuthZone

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

Source §

type VariantFieldsRef<'a> = &'a PushToAuthZone

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#27}::OwnedVariant::{constant#0}, <PushToAuthZone as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#27}::BorrowedVariant::{constant#0}, <PushToAuthZone as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for ReturnToWorktop

Source §

const DISCRIMINATOR: u8 = 3u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = ReturnToWorktop

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

Source §

type VariantFieldsRef<'a> = &'a ReturnToWorktop

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#14}::OwnedVariant::{constant#0}, <ReturnToWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#14}::BorrowedVariant::{constant#0}, <ReturnToWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for TakeAllFromWorktop

Source §

const DISCRIMINATOR: u8 = 2u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = TakeAllFromWorktop

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

Source §

type VariantFieldsRef<'a> = &'a TakeAllFromWorktop

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#13}::OwnedVariant::{constant#0}, <TakeAllFromWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#13}::BorrowedVariant::{constant#0}, <TakeAllFromWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for TakeFromWorktop

Source §

const DISCRIMINATOR: u8 = 0u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = TakeFromWorktop

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

Source §

type VariantFieldsRef<'a> = &'a TakeFromWorktop

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#11}::OwnedVariant::{constant#0}, <TakeFromWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#11}::BorrowedVariant::{constant#0}, <TakeFromWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV1, ManifestCustomValueKind> for TakeNonFungiblesFromWorktop

Source §

const DISCRIMINATOR: u8 = 1u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = TakeNonFungiblesFromWorktop

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

Source §

type VariantFieldsRef<'a> = &'a TakeNonFungiblesFromWorktop

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

Source §

type OwnedVariant = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#12}::OwnedVariant::{constant#0}, <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFields>

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

Source §

type BorrowedVariant<'a> = SborFixedEnumVariant<radix_transactions::::model::v1::instruction_v1::{impl#12}::BorrowedVariant::{constant#0}, <TakeNonFungiblesFromWorktop as SborEnumVariantFor<InstructionV1, ManifestCustomValueKind>>::VariantFieldsRef<'a>>

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

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV1

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AllocateGlobalAddress

Source §

const DISCRIMINATOR: u8 = 81u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AllocateGlobalAddress

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

Source §

type VariantFieldsRef<'a> = &'a AllocateGlobalAddress

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertBucketContents

Source §

const DISCRIMINATOR: u8 = 12u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertBucketContents

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

Source §

type VariantFieldsRef<'a> = &'a AssertBucketContents

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertNextCallReturnsInclude

Source §

const DISCRIMINATOR: u8 = 11u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertNextCallReturnsInclude

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

Source §

type VariantFieldsRef<'a> = &'a AssertNextCallReturnsInclude

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertNextCallReturnsOnly

Source §

const DISCRIMINATOR: u8 = 10u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertNextCallReturnsOnly

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

Source §

type VariantFieldsRef<'a> = &'a AssertNextCallReturnsOnly

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopContains

Source §

const DISCRIMINATOR: u8 = 4u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopContains

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopContains

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopContainsAny

Source §

const DISCRIMINATOR: u8 = 6u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopContainsAny

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopContainsAny

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopContainsNonFungibles

Source §

const DISCRIMINATOR: u8 = 5u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopContainsNonFungibles

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopContainsNonFungibles

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopResourcesInclude

Source §

const DISCRIMINATOR: u8 = 9u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopResourcesInclude

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopResourcesInclude

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for AssertWorktopResourcesOnly

Source §

const DISCRIMINATOR: u8 = 8u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = AssertWorktopResourcesOnly

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

Source §

type VariantFieldsRef<'a> = &'a AssertWorktopResourcesOnly

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for BurnResource

Source §

const DISCRIMINATOR: u8 = 36u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = BurnResource

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

Source §

type VariantFieldsRef<'a> = &'a BurnResource

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallDirectVaultMethod

Source §

const DISCRIMINATOR: u8 = 69u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallDirectVaultMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallDirectVaultMethod

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallFunction

Source §

const DISCRIMINATOR: u8 = 64u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallFunction

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

Source §

type VariantFieldsRef<'a> = &'a CallFunction

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallMetadataMethod

Source §

const DISCRIMINATOR: u8 = 67u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallMetadataMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallMetadataMethod

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallMethod

Source §

const DISCRIMINATOR: u8 = 65u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallMethod

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallRoleAssignmentMethod

Source §

const DISCRIMINATOR: u8 = 68u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallRoleAssignmentMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallRoleAssignmentMethod

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CallRoyaltyMethod

Source §

const DISCRIMINATOR: u8 = 66u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CallRoyaltyMethod

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

Source §

type VariantFieldsRef<'a> = &'a CallRoyaltyMethod

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CloneProof

Source §

const DISCRIMINATOR: u8 = 48u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CloneProof

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

Source §

type VariantFieldsRef<'a> = &'a CloneProof

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromAuthZoneOfAll

Source §

const DISCRIMINATOR: u8 = 22u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromAuthZoneOfAll

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfAll

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromAuthZoneOfAmount

Source §

const DISCRIMINATOR: u8 = 20u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromAuthZoneOfAmount

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfAmount

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromAuthZoneOfNonFungibles

Source §

const DISCRIMINATOR: u8 = 21u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromAuthZoneOfNonFungibles

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromAuthZoneOfNonFungibles

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromBucketOfAll

Source §

const DISCRIMINATOR: u8 = 35u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromBucketOfAll

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfAll

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromBucketOfAmount

Source §

const DISCRIMINATOR: u8 = 33u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromBucketOfAmount

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfAmount

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for CreateProofFromBucketOfNonFungibles

Source §

const DISCRIMINATOR: u8 = 34u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = CreateProofFromBucketOfNonFungibles

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

Source §

type VariantFieldsRef<'a> = &'a CreateProofFromBucketOfNonFungibles

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAllProofs

Source §

const DISCRIMINATOR: u8 = 80u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAllProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAllProofs

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAuthZoneProofs

Source §

const DISCRIMINATOR: u8 = 18u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAuthZoneProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAuthZoneProofs

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAuthZoneRegularProofs

Source §

const DISCRIMINATOR: u8 = 19u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAuthZoneRegularProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAuthZoneRegularProofs

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropAuthZoneSignatureProofs

Source §

const DISCRIMINATOR: u8 = 23u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropAuthZoneSignatureProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropAuthZoneSignatureProofs

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropNamedProofs

Source §

const DISCRIMINATOR: u8 = 82u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropNamedProofs

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

Source §

type VariantFieldsRef<'a> = &'a DropNamedProofs

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for DropProof

Source §

const DISCRIMINATOR: u8 = 49u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = DropProof

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

Source §

type VariantFieldsRef<'a> = &'a DropProof

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for PopFromAuthZone

Source §

const DISCRIMINATOR: u8 = 16u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = PopFromAuthZone

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

Source §

type VariantFieldsRef<'a> = &'a PopFromAuthZone

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for PushToAuthZone

Source §

const DISCRIMINATOR: u8 = 17u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = PushToAuthZone

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

Source §

type VariantFieldsRef<'a> = &'a PushToAuthZone

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for ReturnToWorktop

Source §

const DISCRIMINATOR: u8 = 3u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = ReturnToWorktop

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

Source §

type VariantFieldsRef<'a> = &'a ReturnToWorktop

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for TakeAllFromWorktop

Source §

const DISCRIMINATOR: u8 = 2u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = TakeAllFromWorktop

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

Source §

type VariantFieldsRef<'a> = &'a TakeAllFromWorktop

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for TakeFromWorktop

Source §

const DISCRIMINATOR: u8 = 0u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = TakeFromWorktop

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

Source §

type VariantFieldsRef<'a> = &'a TakeFromWorktop

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for TakeNonFungiblesFromWorktop

Source §

const DISCRIMINATOR: u8 = 1u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = TakeNonFungiblesFromWorktop

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

Source §

type VariantFieldsRef<'a> = &'a TakeNonFungiblesFromWorktop

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for VerifyParent

Source §

const DISCRIMINATOR: u8 = 98u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = VerifyParent

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

Source §

type VariantFieldsRef<'a> = &'a VerifyParent

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for YieldToChild

Source §

const DISCRIMINATOR: u8 = 97u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = YieldToChild

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

Source §

type VariantFieldsRef<'a> = &'a YieldToChild

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

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()?). Read more

Source §

impl SborEnumVariantFor<InstructionV2, ManifestCustomValueKind> for YieldToParent

Source §

const DISCRIMINATOR: u8 = 96u8

Source §

const IS_FLATTENED: bool = true

Source §

type VariantFields = YieldToParent

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

Source §

type VariantFieldsRef<'a> = &'a YieldToParent

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

Source §

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> Read more

Source §

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> Read more

Source §

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

Source §

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

Source §

fn into_enum(self) -> InstructionV2

Source §

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()). Read more

Source §

fn from_decoded_variant(variant: Self::OwnedVariant) -> Self
where Self: Sized,

Source §

impl StructuralPartialEq for ManifestCustomValueKind

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

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

Source §

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

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

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

Source §

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

Source §

Drops the object pointed to by the given pointer. Read more

Source §

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

Source §

fn resolve(self) -> Y

Source §

impl<T> Same for T

Source §

type Output = T

Should always be Self

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Variants§

Address

Bucket

Proof

Expression

Blob

Decimal

PreciseDecimal

NonFungibleLocalId

AddressReservation

Trait Implementations§

impl Categorize<ManifestCustomValueKind> for AccessControllerBlueprintDirectMethod

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerBlueprintFunction

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerBlueprintInvocation

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerBlueprintMethod

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerCancelPrimaryRoleBadgeWithdrawAttemptInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerCancelPrimaryRoleRecoveryProposalInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerCancelRecoveryRoleBadgeWithdrawAttemptInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerCancelRecoveryRoleRecoveryProposalInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerContributeRecoveryFeeManifestInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerCreateManifestInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerCreateProofInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerInitiateBadgeWithdrawAttemptAsPrimaryInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerInitiateBadgeWithdrawAttemptAsRecoveryInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerInitiateRecoveryAsPrimaryInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerInitiateRecoveryAsRecoveryInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerLockPrimaryRoleInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerLockRecoveryFeeInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerMintRecoveryBadgesInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerQuickConfirmPrimaryRoleBadgeWithdrawAttemptInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerQuickConfirmPrimaryRoleRecoveryProposalInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerQuickConfirmRecoveryRoleBadgeWithdrawAttemptInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerQuickConfirmRecoveryRoleRecoveryProposalInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerStopTimedRecoveryInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerTimedConfirmRecoveryInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerUnlockPrimaryRoleInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessControllerWithdrawRecoveryFeeInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccessRule

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccountAddAuthorizedDepositorInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccountAddAuthorizedDepositorManifestInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccountBalanceDynamicInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccountBalanceInput

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccountBlueprintDirectMethod

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccountBlueprintFunction

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ManifestCustomValueKind> for AccountBlueprintInvocation

fn value_kind() -> ValueKind<ManifestCustomValueKind>

Enum ManifestCustomValueKind