Enum AnyTransaction

pub enum AnyTransaction {
    TransactionIntentV1(IntentV1),
    SignedTransactionIntentV1(SignedIntentV1),
    NotarizedTransactionV1(NotarizedTransactionV1),
    SystemTransactionV1(SystemTransactionV1),
    RoundUpdateTransactionV1(RoundUpdateTransactionV1),
    LedgerTransaction(LedgerTransaction),
    FlashTransactionV1(FlashTransactionV1),
    TransactionIntentV2(TransactionIntentV2),
    SignedTransactionIntentV2(SignedTransactionIntentV2),
    SubintentV2(SubintentV2),
    NotarizedTransactionV2(NotarizedTransactionV2),
    PartialTransactionV2(PartialTransactionV2),
    SignedPartialTransactionV2(SignedPartialTransactionV2),
    PreviewTransactionV2(PreviewTransactionV2),
}

An enum of a variety of different transaction payload types.

Running to_payload_bytes() on each transaction type gives the same as Manifest SBOR encoding the variant of this enum.

For this reason, this type might see use in the Node’s transaction parse API, and in other places where we want to decode or handle an arbitrary transaction payload.

All the transaction types also implement ScryptoDescribe, primarily so that they can derive ScryptoSborAssertion to ensure we don’t change the types accidentally.

Variants

TransactionIntentV1(IntentV1)

SignedTransactionIntentV1(SignedIntentV1)

NotarizedTransactionV1(NotarizedTransactionV1)

SystemTransactionV1(SystemTransactionV1)

RoundUpdateTransactionV1(RoundUpdateTransactionV1)

LedgerTransaction(LedgerTransaction)

FlashTransactionV1(FlashTransactionV1)

TransactionIntentV2(TransactionIntentV2)

SignedTransactionIntentV2(SignedTransactionIntentV2)

SubintentV2(SubintentV2)

NotarizedTransactionV2(NotarizedTransactionV2)

PartialTransactionV2(PartialTransactionV2)

SignedPartialTransactionV2(SignedPartialTransactionV2)

PreviewTransactionV2(PreviewTransactionV2)

Trait Implementations

impl Categorize<ManifestCustomValueKind> for AnyTransaction

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Clone for AnyTransaction

fn clone(&self) -> AnyTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AnyTransaction

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

Formats the value using the given formatter.

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

where D: Decoder<ManifestCustomValueKind>,

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

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

impl Describe<ScryptoCustomTypeKind> for AnyTransaction

const TYPE_ID: RustTypeId

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

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

Returns the local schema for the given type.

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

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

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

where E: Encoder<ManifestCustomValueKind>,

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

Encodes the SBOR value’s kind to the encoder

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

Encodes the SBOR body of the type to the encoder.

impl PartialEq for AnyTransaction

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

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

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

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

impl SborEnum<ManifestCustomValueKind> for AnyTransaction

fn get_discriminator(&self) -> u8

fn get_length(&self) -> usize

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for FlashTransactionV1

const DISCRIMINATOR: u8 = 8u8

const IS_FLATTENED: bool = true

type VariantFields = FlashTransactionV1

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

type VariantFieldsRef<'a> = &'a FlashTransactionV1

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for IntentV1

const DISCRIMINATOR: u8 = 1u8

const IS_FLATTENED: bool = true

type VariantFields = IntentV1

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

type VariantFieldsRef<'a> = &'a IntentV1

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for LedgerTransaction

const DISCRIMINATOR: u8 = 7u8

const IS_FLATTENED: bool = false

type VariantFields = (LedgerTransaction,)

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

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

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for NotarizedTransactionV1

const DISCRIMINATOR: u8 = 3u8

const IS_FLATTENED: bool = true

type VariantFields = NotarizedTransactionV1

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

type VariantFieldsRef<'a> = &'a NotarizedTransactionV1

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for NotarizedTransactionV2

const DISCRIMINATOR: u8 = 12u8

const IS_FLATTENED: bool = true

type VariantFields = NotarizedTransactionV2

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

type VariantFieldsRef<'a> = &'a NotarizedTransactionV2

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for PartialTransactionV2

const DISCRIMINATOR: u8 = 13u8

const IS_FLATTENED: bool = true

type VariantFields = PartialTransactionV2

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

type VariantFieldsRef<'a> = &'a PartialTransactionV2

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for PreviewTransactionV2

const DISCRIMINATOR: u8 = 15u8

const IS_FLATTENED: bool = true

type VariantFields = PreviewTransactionV2

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

type VariantFieldsRef<'a> = &'a PreviewTransactionV2

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for RoundUpdateTransactionV1

const DISCRIMINATOR: u8 = 5u8

const IS_FLATTENED: bool = true

type VariantFields = RoundUpdateTransactionV1

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

type VariantFieldsRef<'a> = &'a RoundUpdateTransactionV1

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SignedIntentV1

const DISCRIMINATOR: u8 = 2u8

const IS_FLATTENED: bool = true

type VariantFields = SignedIntentV1

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

type VariantFieldsRef<'a> = &'a SignedIntentV1

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SignedPartialTransactionV2

const DISCRIMINATOR: u8 = 14u8

const IS_FLATTENED: bool = true

type VariantFields = SignedPartialTransactionV2

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

type VariantFieldsRef<'a> = &'a SignedPartialTransactionV2

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SignedTransactionIntentV2

const DISCRIMINATOR: u8 = 10u8

const IS_FLATTENED: bool = true

type VariantFields = SignedTransactionIntentV2

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

type VariantFieldsRef<'a> = &'a SignedTransactionIntentV2

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SubintentV2

const DISCRIMINATOR: u8 = 11u8

const IS_FLATTENED: bool = true

type VariantFields = SubintentV2

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

type VariantFieldsRef<'a> = &'a SubintentV2

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for SystemTransactionV1

const DISCRIMINATOR: u8 = 4u8

const IS_FLATTENED: bool = true

type VariantFields = SystemTransactionV1

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

type VariantFieldsRef<'a> = &'a SystemTransactionV1

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl SborEnumVariantFor<AnyTransaction, ManifestCustomValueKind> for TransactionIntentV2

const DISCRIMINATOR: u8 = 9u8

const IS_FLATTENED: bool = true

type VariantFields = TransactionIntentV2

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

type VariantFieldsRef<'a> = &'a TransactionIntentV2

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

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>

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>

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

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

fn into_enum(self) -> AnyTransaction

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

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

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

where Self: Sized,

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

impl CheckedBackwardsCompatibleSchema<ScryptoCustomSchema> for AnyTransaction

impl Eq for AnyTransaction

impl StructuralPartialEq for AnyTransaction