miden-standards 0.15.2

Standards of the Miden protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use alloc::collections::BTreeSet;
use alloc::vec::Vec;

use miden_protocol::account::AccountProcedureRoot;

use crate::account::access::{Authority, Ownable2Step, RoleBasedAccessControl};
use crate::account::auth::{
    AuthGuardedMultisig,
    AuthMultisig,
    AuthMultisigSmart,
    AuthNetworkAccount,
    AuthSingleSig,
    AuthSingleSigAcl,
    NoAuth,
};
use crate::account::faucets::FungibleFaucet;
use crate::account::interface::AccountComponentInterface;
use crate::account::wallets::BasicWallet;

// STANDARD ACCOUNT COMPONENTS
// ================================================================================================

/// The enum holding the types of standard account components defined in the `miden-standards`
/// crate.
pub enum StandardAccountComponent {
    BasicWallet,
    FungibleFaucet,
    Authority,
    Ownable2Step,
    RoleBasedAccessControl,
    AuthSingleSig,
    AuthSingleSigAcl,
    AuthMultisig,
    AuthMultisigSmart,
    AuthGuardedMultisig,
    AuthNoAuth,
    AuthNetworkAccount,
}

impl StandardAccountComponent {
    /// Returns the iterator over the [`AccountProcedureRoot`]s of all procedures exported from
    /// the component.
    pub fn procedure_roots(&self) -> impl Iterator<Item = AccountProcedureRoot> {
        let code = match self {
            Self::BasicWallet => BasicWallet::code(),
            Self::FungibleFaucet => FungibleFaucet::code(),
            Self::Authority => Authority::code(),
            Self::Ownable2Step => Ownable2Step::code(),
            Self::RoleBasedAccessControl => RoleBasedAccessControl::code(),
            Self::AuthSingleSig => AuthSingleSig::code(),
            Self::AuthSingleSigAcl => AuthSingleSigAcl::code(),
            Self::AuthMultisig => AuthMultisig::code(),
            Self::AuthMultisigSmart => AuthMultisigSmart::code(),
            Self::AuthGuardedMultisig => AuthGuardedMultisig::code(),
            Self::AuthNoAuth => NoAuth::code(),
            Self::AuthNetworkAccount => AuthNetworkAccount::code(),
        };

        code.procedure_roots()
    }

    /// Checks whether procedures from the current component are present in the procedures map
    /// and if so it removes these procedures from this map and pushes the corresponding component
    /// interface to the component interface vector.
    fn extract_component(
        &self,
        procedures_set: &mut BTreeSet<AccountProcedureRoot>,
        component_interface_vec: &mut Vec<AccountComponentInterface>,
    ) {
        // Determine if this component should be extracted based on procedure matching
        if self.procedure_roots().all(|proc_root| procedures_set.contains(&proc_root)) {
            // Remove the procedure root of any matching procedure.
            self.procedure_roots().for_each(|component_procedure| {
                procedures_set.remove(&component_procedure);
            });

            // Create the appropriate component interface
            match self {
                Self::BasicWallet => {
                    component_interface_vec.push(AccountComponentInterface::BasicWallet)
                },
                Self::FungibleFaucet => {
                    component_interface_vec.push(AccountComponentInterface::FungibleFaucet)
                },
                Self::Authority => {
                    component_interface_vec.push(AccountComponentInterface::Authority)
                },
                Self::Ownable2Step => {
                    component_interface_vec.push(AccountComponentInterface::Ownable2Step)
                },
                Self::RoleBasedAccessControl => {
                    component_interface_vec.push(AccountComponentInterface::RoleBasedAccessControl)
                },
                Self::AuthSingleSig => {
                    component_interface_vec.push(AccountComponentInterface::AuthSingleSig)
                },
                Self::AuthSingleSigAcl => {
                    component_interface_vec.push(AccountComponentInterface::AuthSingleSigAcl)
                },
                Self::AuthMultisig => {
                    component_interface_vec.push(AccountComponentInterface::AuthMultisig)
                },
                Self::AuthMultisigSmart => {
                    component_interface_vec.push(AccountComponentInterface::AuthMultisigSmart)
                },
                Self::AuthGuardedMultisig => {
                    component_interface_vec.push(AccountComponentInterface::AuthGuardedMultisig)
                },
                Self::AuthNoAuth => {
                    component_interface_vec.push(AccountComponentInterface::AuthNoAuth)
                },
                Self::AuthNetworkAccount => {
                    component_interface_vec.push(AccountComponentInterface::AuthNetworkAccount)
                },
            }
        }
    }

    /// Gets all standard components which could be constructed from the provided procedures map
    /// and pushes them to the `component_interface_vec`.
    pub fn extract_standard_components(
        procedures_set: &mut BTreeSet<AccountProcedureRoot>,
        component_interface_vec: &mut Vec<AccountComponentInterface>,
    ) {
        Self::BasicWallet.extract_component(procedures_set, component_interface_vec);
        Self::FungibleFaucet.extract_component(procedures_set, component_interface_vec);
        Self::Authority.extract_component(procedures_set, component_interface_vec);
        Self::RoleBasedAccessControl.extract_component(procedures_set, component_interface_vec);
        Self::Ownable2Step.extract_component(procedures_set, component_interface_vec);
        Self::AuthSingleSig.extract_component(procedures_set, component_interface_vec);
        Self::AuthSingleSigAcl.extract_component(procedures_set, component_interface_vec);
        Self::AuthGuardedMultisig.extract_component(procedures_set, component_interface_vec);
        Self::AuthMultisig.extract_component(procedures_set, component_interface_vec);
        Self::AuthMultisigSmart.extract_component(procedures_set, component_interface_vec);
        Self::AuthNoAuth.extract_component(procedures_set, component_interface_vec);
        Self::AuthNetworkAccount.extract_component(procedures_set, component_interface_vec);
    }
}