Enum Authority 

#[non_exhaustive]
#[repr(u8)]
pub enum Authority {
    AuthControlled = 0,
    OwnerControlled = 1,
    RbacControlled {
        roles: BTreeMap<AccountProcedureRoot, RoleSymbol>,
    },
}

Identifies which authority is allowed to invoke an authority-gated procedure on an account.

Components that gate state-mutating procedures (such as TokenPolicyManager for set_mint_policy / set_burn_policy, or the fungible token metadata setters) consult this shared slot via the MASM helper authority::assert_authorized. Installing the Authority component on an account thus selects the gating mode for all such procedures in one place.

Safety invariant for Authority::AuthControlled

Because assert_authorized is a no-op under AuthControlled, the account’s auth component is the sole gate for every authority-gated setter. The auth component MUST therefore authenticate every such setter root, otherwise the setters become permissionless.

Per-procedure roles under Authority::RbacControlled

Under RBAC, each gated procedure can be assigned its own role via roles, keyed by the procedure’s AccountProcedureRoot (e.g. pause → PAUSER, unpause → UNPAUSER). At runtime assert_authorized identifies the calling procedure via the caller instruction and looks up its role. A procedure without a mapping falls back to the ADMIN role check.

Emergency switch (is_frozen)

The component includes an is_frozen flag. If it is true, all procedures that call assert_authorized would panic, effectively freezing them. Accounts are always constructed unfrozen.

The flag is toggled via freeze / unfreeze. Under Authority::OwnerControlled these are gated on the Ownable2Step owner; under Authority::RbacControlled they resolve their role from the role map (e.g. FREEZER / UNFREEZER), defaulting to the ADMIN role. Both bypass the frozen flag itself so the switch can always be toggled.

This flag has no effect under Authority::AuthControlled, where freeze / unfreeze panic (there is no owner and no role graph).

Storage layout:

• Value slot: [authority, is_frozen, 0, 0].
• Map slot (only under RBAC): procedure_root → [role_symbol, 0, 0, 0].

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AuthControlled = 0

Authority is the account’s auth component.

OwnerControlled = 1

Authority is the Ownable2Step owner.

RbacControlled

Authority is membership in an RBAC role, resolved per gated procedure.

roles maps a gated procedure’s AccountProcedureRoot to the role required to invoke it. Requires the RoleBasedAccessControl component to be installed on the account. the MASM helper calls into rbac::assert_sender_has_role and will fail to link otherwise.

Fields

roles: BTreeMap<AccountProcedureRoot, RoleSymbol>

Implementations

impl Authority

pub const NAME: &'static str = "miden::standards::components::access::authority"

The name of the component.

pub fn code() -> &'static AccountComponentCode

Returns the AccountComponentCode of this component.

pub fn freeze_root() -> AccountProcedureRoot

Returns the procedure root of the freeze emergency switch.

Under Authority::OwnerControlled this is gated on the owner. Under Authority::RbacControlled it may be assigned its own role via the role map (e.g. FREEZER); when unmapped it falls back to the ADMIN role. Unlike ordinary gated procedures it bypasses the frozen flag so it can always be toggled.

pub fn unfreeze_root() -> AccountProcedureRoot

Returns the procedure root of the unfreeze emergency switch.

Under Authority::OwnerControlled this is gated on the owner. Under Authority::RbacControlled it may be assigned its own role via the role map (e.g. UNFREEZER); when unmapped it falls back to the ADMIN role. Unlike ordinary gated procedures it bypasses the frozen flag so it can always be toggled.

pub fn authority_slot() -> &'static StorageSlotName

Returns the StorageSlotName holding the authority configuration.

pub fn procedure_roles_slot() -> &'static StorageSlotName

Returns the StorageSlotName holding the per-procedure role map (RBAC only).

pub fn try_from_storage( storage: &AccountStorage, ) -> Result<Authority, AuthorityError>

Reads the authority configuration from account storage.

pub fn try_read_frozen(storage: &AccountStorage) -> Result<bool, AuthorityError>

Reads the is_frozen emergency-switch flag from account storage.

Returns true if the account’s authority-gated surface is currently frozen (every procedure that calls assert_authorized panics until it is unfrozen).

pub fn component_metadata(&self) -> AccountComponentMetadata

Returns the AccountComponentMetadata for this configuration.

Trait Implementations

impl Clone for Authority

fn clone(&self) -> Authority

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Authority

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

Formats the value using the given formatter.

impl Eq for Authority

impl From<Authority> for AccountComponent

fn from(value: Authority) -> AccountComponent

Converts to this type from the input type.

impl PartialEq for Authority

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Authority