Enum AccessControl 

pub enum AccessControl {
    Ownable2Step {
        owner: AccountId,
    },
    Rbac {
        admin: AccountId,
        procedure_roles: BTreeMap<AccountProcedureRoot, RoleSymbol>,
    },
}

Access control configuration for network-style accounts whose authority-gated setters are gated by an owner / role check rather than by the account’s auth component.

User-account faucets (where the auth component is itself the setter gate) install Authority::AuthControlled directly via factories like create_singlesig_user_fungible_faucet; they do not need this enum.

• AccessControl::Ownable2Step → Ownable2Step + Authority::OwnerControlled. The setter gate enforces sender == owner.
• AccessControl::Rbac → RoleBasedAccessControl + Authority::RbacControlled. The procedure_roles map assigns a role to individual gated procedures (keyed by procedure root); procedures without a mapping fall back to the ADMIN role check.

Pass to AccountBuilder::with_components to install the access control components on the account:

use std::collections::BTreeMap;

use miden_protocol::account::AccountBuilder;
use miden_standards::account::access::AccessControl;
AccountBuilder::new(init_seed)
    .with_components(AccessControl::Rbac { admin, procedure_roles: BTreeMap::new() });

For accounts that don’t use the AccessControl convenience but want to install the Authority component directly, the Authority enum can be passed via AccountBuilder::with_component.

Variants

Ownable2Step

Two-step ownership transfer with the provided initial owner. The setter gate enforces sender == owner.

Fields

owner: AccountId

Rbac

Role-based access control. The provided admin is seeded as the initial member of the RBAC ADMIN role, which bootstraps role administration.

Role administration itself is fully role-based. Each role is managed by its effective admin role (its delegated admin, or ADMIN by default). See RoleBasedAccessControl for the administration model.

procedure_roles assigns a role to individual authority-gated procedures, keyed by procedure root (e.g. PausableManager::pause_root() → PAUSER, unpause_root() → UNPAUSER, and optionally Authority::freeze_root() → FREEZER). A gated procedure without an entry in procedure_roles falls back to the ADMIN role. The emergency freeze / unfreeze switch resolves its role the same way, defaulting to ADMIN. Role membership is managed through the standard RBAC API on the RoleBasedAccessControl component.

Fields

admin: AccountId

procedure_roles: BTreeMap<AccountProcedureRoot, RoleSymbol>

Trait Implementations

impl Clone for AccessControl

fn clone(&self) -> AccessControl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccessControl

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

Formats the value using the given formatter.

impl Eq for AccessControl

impl IntoIterator for AccessControl

fn into_iter(self) -> <AccessControl as IntoIterator>::IntoIter

Yields the AccountComponents implementing this access control configuration, in the order they must be installed on the account. The matching Authority component is always included.

type Item = AccountComponent

The type of the elements being iterated over.

type IntoIter = IntoIter<AccountComponent>

Which kind of iterator are we turning this into?

impl PartialEq for AccessControl

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AccessControl