Struct AccessControllerV1Substate

pub struct AccessControllerV1Substate {
    pub controlled_asset: Vault,
    pub timed_recovery_delay_in_minutes: Option<u32>,
    pub recovery_badge: ResourceAddress,
    pub state: (PrimaryRoleLockingState, PrimaryRoleRecoveryAttemptState, PrimaryRoleBadgeWithdrawAttemptState, RecoveryRoleRecoveryAttemptState, RecoveryRoleBadgeWithdrawAttemptState),
}

Fields

controlled_asset: Vault

A vault where the asset controlled by the access controller lives.

timed_recovery_delay_in_minutes: Option<u32>

The amount of time (in minutes) that it takes for timed recovery to be done. Maximum is 4,294,967,295 minutes which is 8171.5511700913 years. When this is None, then timed recovery can not be performed through this access controller.

recovery_badge: ResourceAddress

The resource address of the recovery badge that will be used by the wallet and optionally by other clients as well.

state: (PrimaryRoleLockingState, PrimaryRoleRecoveryAttemptState, PrimaryRoleBadgeWithdrawAttemptState, RecoveryRoleRecoveryAttemptState, RecoveryRoleBadgeWithdrawAttemptState)

The states of the Access Controller.

Implementations

impl AccessControllerV1Substate

pub fn new( controlled_asset: Vault, timed_recovery_delay_in_minutes: Option<u32>, recovery_badge: ResourceAddress, ) -> AccessControllerV1Substate

Trait Implementations

impl Categorize<ScryptoCustomValueKind> for AccessControllerV1Substate

fn value_kind() -> ValueKind<ScryptoCustomValueKind>

impl Debug for AccessControllerV1Substate

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

Formats the value using the given formatter.

impl<D> Decode<ScryptoCustomValueKind, D> for AccessControllerV1Substate

where D: Decoder<ScryptoCustomValueKind>,

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

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

impl Describe<ScryptoCustomTypeKind> for AccessControllerV1Substate

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<ScryptoCustomValueKind, E> for AccessControllerV1Substate

where E: Encoder<ScryptoCustomValueKind>,

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 FieldContentSource<AccessControllerStateFieldPayload> for AccessControllerV1Substate

fn into_content(self) -> VersionedAccessControllerState

fn into_payload(self) -> Payload

fn into_locked_substate(self) -> FieldSubstate<Payload>

fn into_unlocked_substate(self) -> FieldSubstate<Payload>

impl FieldContentSource<AccessControllerV2StateFieldPayload> for AccessControllerV1Substate

fn into_content(self) -> VersionedAccessControllerV2State

fn into_payload(self) -> Payload

fn into_locked_substate(self) -> FieldSubstate<Payload>

fn into_unlocked_substate(self) -> FieldSubstate<Payload>

impl From<AccessControllerV1Substate> for AccessControllerStateVersions

fn from(value: AccessControllerV1Substate) -> AccessControllerStateVersions

Converts to this type from the input type.

impl From<AccessControllerV1Substate> for AccessControllerV2StateVersions

fn from(value: AccessControllerV1Substate) -> AccessControllerV2StateVersions

Converts to this type from the input type.

impl From<AccessControllerV1Substate> for AccessControllerV2Substate

fn from(_: AccessControllerV1Substate) -> AccessControllerV2Substate

Converts to this type from the input type.

impl From<AccessControllerV1Substate> for VersionedAccessControllerState

fn from(value: AccessControllerV1Substate) -> VersionedAccessControllerState

Converts to this type from the input type.

impl From<AccessControllerV1Substate> for VersionedAccessControllerV2State

fn from(value: AccessControllerV1Substate) -> VersionedAccessControllerV2State

Converts to this type from the input type.

impl PartialEq for AccessControllerV1Substate

fn eq(&self, other: &AccessControllerV1Substate) -> 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 SborTuple<ScryptoCustomValueKind> for AccessControllerV1Substate

fn get_length(&self) -> usize

impl VersionedAccessControllerStateVersion for AccessControllerV1Substate

const DISCRIMINATOR: u8 = 0u8

type Versioned = VersionedAccessControllerState

type OwnedSborVariant = SborFixedEnumVariant<radix_engine::::blueprints::access_controller::v1::state::access_controller_models::{impl#83}::OwnedSborVariant::{constant#0}, (AccessControllerV1Substate,)>

type BorrowedSborVariant<'a> = SborFixedEnumVariant<radix_engine::::blueprints::access_controller::v1::state::access_controller_models::{impl#83}::BorrowedSborVariant::{constant#0}, (&'a AccessControllerV1Substate,)> where AccessControllerV1Substate: 'a

fn as_encodable_variant( &self, ) -> <AccessControllerV1Substate as VersionedAccessControllerStateVersion>::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: <AccessControllerV1Substate as VersionedAccessControllerStateVersion>::OwnedSborVariant, ) -> AccessControllerV1Substate

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

fn into_versioned( self, ) -> <AccessControllerV1Substate as VersionedAccessControllerStateVersion>::Versioned

impl VersionedAccessControllerV2StateVersion for AccessControllerV1Substate

const DISCRIMINATOR: u8 = 0u8

type Versioned = VersionedAccessControllerV2State

type OwnedSborVariant = SborFixedEnumVariant<radix_engine::::blueprints::access_controller::v2::state::access_controller_models::{impl#86}::OwnedSborVariant::{constant#0}, (AccessControllerV1Substate,)>

type BorrowedSborVariant<'a> = SborFixedEnumVariant<radix_engine::::blueprints::access_controller::v2::state::access_controller_models::{impl#86}::BorrowedSborVariant::{constant#0}, (&'a AccessControllerV1Substate,)> where AccessControllerV1Substate: 'a

fn as_encodable_variant( &self, ) -> <AccessControllerV1Substate as VersionedAccessControllerV2StateVersion>::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: <AccessControllerV1Substate as VersionedAccessControllerV2StateVersion>::OwnedSborVariant, ) -> AccessControllerV1Substate

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

fn into_versioned( self, ) -> <AccessControllerV1Substate as VersionedAccessControllerV2StateVersion>::Versioned

impl Eq for AccessControllerV1Substate

impl StructuralPartialEq for AccessControllerV1Substate