Struct TransactionValidationConfigV1 

pub struct TransactionValidationConfigV1 {

    pub max_signer_signatures_per_intent: usize,
    pub max_references_per_intent: usize,
    pub min_tip_percentage: u16,
    pub max_tip_percentage: u16,
    pub max_epoch_range: u64,
    pub max_instructions: usize,
    pub message_validation: MessageValidationConfig,
    pub v1_transactions_allow_notary_to_duplicate_signer: bool,
    pub preparation_settings: PreparationSettingsV1,
    pub manifest_validation: ManifestValidationRuleset,
    pub v2_transactions_allowed: bool,
    pub min_tip_basis_points: u32,
    pub max_tip_basis_points: u32,
    pub max_subintent_depth: usize,
    pub max_total_signature_validations: usize,
    pub max_total_references: usize,
}

Fields

max_signer_signatures_per_intent: usize

Signer signatures only, not including notary signature

max_references_per_intent: usize

min_tip_percentage: u16

max_tip_percentage: u16

max_epoch_range: u64

max_instructions: usize

message_validation: MessageValidationConfig

v1_transactions_allow_notary_to_duplicate_signer: bool

preparation_settings: PreparationSettingsV1

manifest_validation: ManifestValidationRuleset

v2_transactions_allowed: bool

min_tip_basis_points: u32

max_tip_basis_points: u32

max_subintent_depth: usize

A setting of N here allows a total depth of N + 1 if you include the root transaction intent.

max_total_signature_validations: usize

max_total_references: usize

Implementations

impl TransactionValidationConfigV1

pub fn load(database: &impl SubstateDatabase) -> Self

impl TransactionValidationConfigV1

pub const fn latest() -> Self

pub const fn babylon() -> Self

pub const fn cuttlefish() -> Self

Trait Implementations

impl<X: CustomValueKind> Categorize<X> for TransactionValidationConfigV1

fn value_kind() -> ValueKind<X>

impl Clone for TransactionValidationConfigV1

fn clone(&self) -> TransactionValidationConfigV1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionValidationConfigV1

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

Formats the value using the given formatter.

impl<D: Decoder<X>, X: CustomValueKind> Decode<X, D> for TransactionValidationConfigV1

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

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

impl<C: CustomTypeKind<RustTypeId>> Describe<C> for TransactionValidationConfigV1

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<C, RustTypeId>

Returns the local schema for the given type.

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

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

impl<E: Encoder<X>, X: CustomValueKind> Encode<X, E> for TransactionValidationConfigV1

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

Encodes the SBOR value’s kind to the encoder

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

Encodes the SBOR body of the type to the encoder.

impl From<TransactionValidationConfigV1> for TransactionValidationConfigurationSubstate

fn from(value: TransactionValidationConfigV1) -> Self

Converts to this type from the input type.

impl From<TransactionValidationConfigV1> for TransactionValidationConfigurationVersions

fn from(value: TransactionValidationConfigV1) -> Self

Converts to this type from the input type.

impl PartialEq for TransactionValidationConfigV1

fn eq(&self, other: &TransactionValidationConfigV1) -> 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<X: CustomValueKind> SborTuple<X> for TransactionValidationConfigV1

fn get_length(&self) -> usize

impl TransactionValidationConfigurationSubstateVersion for TransactionValidationConfigV1

const DISCRIMINATOR: u8 = 0u8

type Versioned = TransactionValidationConfigurationSubstate

type OwnedSborVariant = SborFixedEnumVariant<$crate::eager_replace! { [!SET! #FullGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?] [!SET! #ImplGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?] [!SET! #TypeGenerics = $(< $( $lt ),+ >)?] [!SET! #VersionedType = $versioned_name $(< $( $lt ),+ >)?] [!SET! #VersionedTypePath = $versioned_name $(::< $( $lt ),+ >)?] [!SET! #VersionsType = $versions_name $(< $( $lt ),+ >)?] [!SET! #VersionsTypePath = $versions_name $(::< $( $lt ),+ >)?] [!SET:ident! #PermitSborAttributesAlias = $versioned_name _PermitSborAttributes] #[allow(dead_code)] $vis type $latest_version_alias = $latest_version_type; use $crate::PermitSborAttributes as #PermitSborAttributesAlias; #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$outer_attributes])*)? // Needs to go below $attributes so that a #[derive(Sbor)] in the attributes can see it. #[sbor(as_type = [!stringify! #VersionsType])] /// If you wish to get access to match on the versions, use `.as_ref()` or `.as_mut()`. $vis struct $versioned_name #FullGenerics { inner: Option<#VersionsType>, } impl #ImplGenerics #VersionedType { pub fn new(inner: #VersionsType) -> Self { Self { inner: Some(inner), } } } impl #ImplGenerics AsRef<#VersionsType> for #VersionedType { fn as_ref(&self) -> &#VersionsType { self.inner.as_ref().unwrap() } } impl #ImplGenerics AsMut<#VersionsType> for #VersionedType { fn as_mut(&mut self) -> &mut #VersionsType { self.inner.as_mut().unwrap() } } impl #ImplGenerics From<#VersionsType> for #VersionedType { fn from(value: #VersionsType) -> Self { Self::new(value) } } impl #ImplGenerics From<#VersionedType> for #VersionsType { fn from(value: #VersionedType) -> Self { value.inner.unwrap() } } impl #ImplGenerics Versioned for #VersionedType { type Versions = #VersionsType; type LatestVersion = $latest_version_type; fn is_fully_updated(&self) -> bool { self.as_ref().is_fully_updated() } fn in_place_fully_update(&mut self) -> &mut Self { if !self.is_fully_updated() { let current = self.inner.take().unwrap(); self.inner = Some(current.fully_update()); } self } fn fully_update_and_into_latest_version(self) -> Self::LatestVersion { self.inner.unwrap().fully_update_and_into_latest_version() } /// Constructs the versioned enum from the latest content fn from_latest_version(latest: Self::LatestVersion) -> Self { Self::new(latest.into()) } fn as_latest_version(&self) -> Option<&Self::LatestVersion> { self.as_ref().as_latest_version() } fn as_latest_version_mut(&mut self) -> Option<&mut Self::LatestVersion> { self.as_mut().as_latest_version_mut() } fn as_versions(&self) -> &Self::Versions { self.as_ref() } fn as_versions_mut(&mut self) -> &mut Self::Versions { self.as_mut() } fn into_versions(self) -> Self::Versions { self.inner.unwrap() } fn from_versions(version: Self::Versions) -> Self { Self::new(version) } } [!SET:ident! #discriminators = $versioned_name _discriminators] #[allow(non_snake_case)] mod #discriminators { // The initial version of this tool used 0-indexed/off-by-one discriminators accidentally. // We're stuck with these now unfortunately... // But we make them explicit in case versions are skipped. $($( pub const [!ident! VERSION_ $version_num]: u8 = $version_num - 1; )*)? pub const LATEST_VERSION: u8 = $latest_version - 1; } #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$inner_attributes])*)? $vis enum $versions_name #FullGenerics { $($( #[sbor(discriminator(#discriminators::[!ident! VERSION_ $version_num]))] [!ident! V $version_num]($version_type), )*)? #[sbor(discriminator(#discriminators::LATEST_VERSION))] [!ident! V $latest_version]($latest_version_type), } #[allow(dead_code)] impl #ImplGenerics #VersionsType { /// Returns if update happened, and the updated versioned enum. fn attempt_single_update(self) -> (bool, Self) { match self { $($( Self::[!ident! V $version_num](value) => (true, Self::[!ident! V $update_to_version_num](value.into())), )*)? this @ Self::[!ident! V $latest_version](_) => (false, this), } } fn fully_update(mut self) -> Self { loop { let (did_update, updated) = self.attempt_single_update(); if did_update { // We should try updating self = updated; } else { // We're at latest - return return updated; } } } #[allow(unreachable_patterns)] pub fn is_fully_updated(&self) -> bool { match self { Self::[!ident! V $latest_version](_) => true, _ => false, } } #[allow(irrefutable_let_patterns)] fn fully_update_and_into_latest_version(self) -> $latest_version_type { let Self::[!ident! V $latest_version](latest) = self.fully_update() else { panic!("Invalid resolved latest version not equal to latest type") }; return latest; } fn from_latest_version(latest: $latest_version_type) -> Self { Self::[!ident! V $latest_version](latest) } #[allow(unreachable_patterns)] fn as_latest_version(&self) -> Option<&$latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } #[allow(unreachable_patterns)] fn as_latest_version_mut(&mut self) -> Option<&mut $latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } pub fn into_versioned(self) -> #VersionedType { #VersionedTypePath::new(self) } } $($( #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionsType { fn from(value: $version_type) -> Self { Self::[!ident! V $version_num](value) } } #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionedType { fn from(value: $version_type) -> Self { Self::new(#VersionsTypePath::[!ident! V $version_num](value)) } } )*)? #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionsType { fn from(value: $latest_version_type) -> Self { Self::[!ident! V $latest_version](value) } } #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionedType { fn from(value: $latest_version_type) -> Self { Self::new($versions_name::[!ident! V $latest_version](value)) } } // This trait is similar to `SborEnumVariantFor<X, Versioned>`, but it's nicer to use as // it's got a better name and can be implemented without needing a specific CustomValueKind. [!SET:ident! #VersionTrait = $versioned_name Version] #[allow(dead_code)] $vis trait #VersionTrait { // Note: We need to use an explicit associated type to capture the generics. type Versioned: sbor::Versioned; const DISCRIMINATOR: u8; type OwnedSborVariant; type BorrowedSborVariant<'a> where Self: 'a; /// Can be used to encode the type as a variant under the Versioned type, without /// needing to clone, like this: `encoder.encode(x.as_encodable_variant())`. fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_>; /// Can be used to decode the type from an encoded variant, like this: /// `X::from_decoded_variant(decoder.decode()?)`. fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self where Self: core::marker::Sized; fn into_versioned(self) -> Self::Versioned; } $($( impl #ImplGenerics #VersionTrait for $version_type { type Versioned = #VersionedType; const DISCRIMINATOR: u8 = #discriminators::[!ident! VERSION_ $version_num]; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } )*)? impl #ImplGenerics #VersionTrait for $latest_version_type { type Versioned = $versioned_name #TypeGenerics; const DISCRIMINATOR: u8 = #discriminators::LATEST_VERSION; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } }, (TransactionValidationConfigV1,)>

type BorrowedSborVariant<'a> = SborFixedEnumVariant<$crate::eager_replace! { [!SET! #FullGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?] [!SET! #ImplGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?] [!SET! #TypeGenerics = $(< $( $lt ),+ >)?] [!SET! #VersionedType = $versioned_name $(< $( $lt ),+ >)?] [!SET! #VersionedTypePath = $versioned_name $(::< $( $lt ),+ >)?] [!SET! #VersionsType = $versions_name $(< $( $lt ),+ >)?] [!SET! #VersionsTypePath = $versions_name $(::< $( $lt ),+ >)?] [!SET:ident! #PermitSborAttributesAlias = $versioned_name _PermitSborAttributes] #[allow(dead_code)] $vis type $latest_version_alias = $latest_version_type; use $crate::PermitSborAttributes as #PermitSborAttributesAlias; #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$outer_attributes])*)? // Needs to go below $attributes so that a #[derive(Sbor)] in the attributes can see it. #[sbor(as_type = [!stringify! #VersionsType])] /// If you wish to get access to match on the versions, use `.as_ref()` or `.as_mut()`. $vis struct $versioned_name #FullGenerics { inner: Option<#VersionsType>, } impl #ImplGenerics #VersionedType { pub fn new(inner: #VersionsType) -> Self { Self { inner: Some(inner), } } } impl #ImplGenerics AsRef<#VersionsType> for #VersionedType { fn as_ref(&self) -> &#VersionsType { self.inner.as_ref().unwrap() } } impl #ImplGenerics AsMut<#VersionsType> for #VersionedType { fn as_mut(&mut self) -> &mut #VersionsType { self.inner.as_mut().unwrap() } } impl #ImplGenerics From<#VersionsType> for #VersionedType { fn from(value: #VersionsType) -> Self { Self::new(value) } } impl #ImplGenerics From<#VersionedType> for #VersionsType { fn from(value: #VersionedType) -> Self { value.inner.unwrap() } } impl #ImplGenerics Versioned for #VersionedType { type Versions = #VersionsType; type LatestVersion = $latest_version_type; fn is_fully_updated(&self) -> bool { self.as_ref().is_fully_updated() } fn in_place_fully_update(&mut self) -> &mut Self { if !self.is_fully_updated() { let current = self.inner.take().unwrap(); self.inner = Some(current.fully_update()); } self } fn fully_update_and_into_latest_version(self) -> Self::LatestVersion { self.inner.unwrap().fully_update_and_into_latest_version() } /// Constructs the versioned enum from the latest content fn from_latest_version(latest: Self::LatestVersion) -> Self { Self::new(latest.into()) } fn as_latest_version(&self) -> Option<&Self::LatestVersion> { self.as_ref().as_latest_version() } fn as_latest_version_mut(&mut self) -> Option<&mut Self::LatestVersion> { self.as_mut().as_latest_version_mut() } fn as_versions(&self) -> &Self::Versions { self.as_ref() } fn as_versions_mut(&mut self) -> &mut Self::Versions { self.as_mut() } fn into_versions(self) -> Self::Versions { self.inner.unwrap() } fn from_versions(version: Self::Versions) -> Self { Self::new(version) } } [!SET:ident! #discriminators = $versioned_name _discriminators] #[allow(non_snake_case)] mod #discriminators { // The initial version of this tool used 0-indexed/off-by-one discriminators accidentally. // We're stuck with these now unfortunately... // But we make them explicit in case versions are skipped. $($( pub const [!ident! VERSION_ $version_num]: u8 = $version_num - 1; )*)? pub const LATEST_VERSION: u8 = $latest_version - 1; } #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$inner_attributes])*)? $vis enum $versions_name #FullGenerics { $($( #[sbor(discriminator(#discriminators::[!ident! VERSION_ $version_num]))] [!ident! V $version_num]($version_type), )*)? #[sbor(discriminator(#discriminators::LATEST_VERSION))] [!ident! V $latest_version]($latest_version_type), } #[allow(dead_code)] impl #ImplGenerics #VersionsType { /// Returns if update happened, and the updated versioned enum. fn attempt_single_update(self) -> (bool, Self) { match self { $($( Self::[!ident! V $version_num](value) => (true, Self::[!ident! V $update_to_version_num](value.into())), )*)? this @ Self::[!ident! V $latest_version](_) => (false, this), } } fn fully_update(mut self) -> Self { loop { let (did_update, updated) = self.attempt_single_update(); if did_update { // We should try updating self = updated; } else { // We're at latest - return return updated; } } } #[allow(unreachable_patterns)] pub fn is_fully_updated(&self) -> bool { match self { Self::[!ident! V $latest_version](_) => true, _ => false, } } #[allow(irrefutable_let_patterns)] fn fully_update_and_into_latest_version(self) -> $latest_version_type { let Self::[!ident! V $latest_version](latest) = self.fully_update() else { panic!("Invalid resolved latest version not equal to latest type") }; return latest; } fn from_latest_version(latest: $latest_version_type) -> Self { Self::[!ident! V $latest_version](latest) } #[allow(unreachable_patterns)] fn as_latest_version(&self) -> Option<&$latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } #[allow(unreachable_patterns)] fn as_latest_version_mut(&mut self) -> Option<&mut $latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } pub fn into_versioned(self) -> #VersionedType { #VersionedTypePath::new(self) } } $($( #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionsType { fn from(value: $version_type) -> Self { Self::[!ident! V $version_num](value) } } #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionedType { fn from(value: $version_type) -> Self { Self::new(#VersionsTypePath::[!ident! V $version_num](value)) } } )*)? #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionsType { fn from(value: $latest_version_type) -> Self { Self::[!ident! V $latest_version](value) } } #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionedType { fn from(value: $latest_version_type) -> Self { Self::new($versions_name::[!ident! V $latest_version](value)) } } // This trait is similar to `SborEnumVariantFor<X, Versioned>`, but it's nicer to use as // it's got a better name and can be implemented without needing a specific CustomValueKind. [!SET:ident! #VersionTrait = $versioned_name Version] #[allow(dead_code)] $vis trait #VersionTrait { // Note: We need to use an explicit associated type to capture the generics. type Versioned: sbor::Versioned; const DISCRIMINATOR: u8; type OwnedSborVariant; type BorrowedSborVariant<'a> where Self: 'a; /// Can be used to encode the type as a variant under the Versioned type, without /// needing to clone, like this: `encoder.encode(x.as_encodable_variant())`. fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_>; /// Can be used to decode the type from an encoded variant, like this: /// `X::from_decoded_variant(decoder.decode()?)`. fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self where Self: core::marker::Sized; fn into_versioned(self) -> Self::Versioned; } $($( impl #ImplGenerics #VersionTrait for $version_type { type Versioned = #VersionedType; const DISCRIMINATOR: u8 = #discriminators::[!ident! VERSION_ $version_num]; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } )*)? impl #ImplGenerics #VersionTrait for $latest_version_type { type Versioned = $versioned_name #TypeGenerics; const DISCRIMINATOR: u8 = #discriminators::LATEST_VERSION; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } }, (&'a TransactionValidationConfigV1,)> where Self: 'a

fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_>

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

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

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

fn into_versioned(self) -> Self::Versioned

impl Copy for TransactionValidationConfigV1

impl Eq for TransactionValidationConfigV1

impl StructuralPartialEq for TransactionValidationConfigV1