Struct AuthMultisig 

pub struct AuthMultisig { /* private fields */ }

An AccountComponent implementing a multisig authentication.

It enforces a threshold of approver signatures for every transaction, with optional per-procedure threshold overrides.

Fees

Before authenticating, auth_tx_multisig pays the transaction fee via miden::standards::auth::multisig::pay_bounded_fee: it creates a public TX_FEE note (see TxFeeNote) funded from the account’s vault, so on fee-charging chains the account must hold a sufficient balance of the native fee asset. The payment asset and conversion rate are committed to via the transaction’s auth args (see FeeConversionInfo and commit_fee_conversion_info), and the payment must be in the native fee asset and at most twice the computed fee (fee::assert_fee_bound): the rate is host-supplied and a per-procedure threshold override can authorize a transaction below the default quorum, so an unbounded payment would let it drain the vault through the fee note. On chains with a zero verification base fee no note is created. The fee note is created before the transaction summary, so it is covered by the approver signatures. The auth args word (the commitment hash(CONVERSION_INFO || SALT)) continues to serve as the transaction summary salt; the uniqueness that replay protection relies on originates from the caller-chosen SALT: distinct salts produce distinct commitments and therefore distinct signed summaries, which record_and_assert_new_tx records and checks.

Privacy

Approvers using AuthScheme::EcdsaK256Keccak disclose their public key and signature at proving time and therefore do not get public-key privacy; approvers using Falcon512Poseidon2 do. See Approver for details.

Security: private accounts and state withholding

A private account’s state lives off-chain; the chain only holds a commitment to it. Whoever advances the account must share the new state with the other approvers, otherwise those approvers can no longer reconstruct the state behind the on-chain commitment and are permanently locked out (and the signers retaining the state can drain its assets). This is a data-availability problem inherent to private state, not an authorization one: the threshold controls who can advance the state, not whether the resulting state is shared. A per-procedure threshold of one lets a single approver do this; more generally, any quorum smaller than the full approver set can advance the state and withhold it from the excluded approvers.

The only configurations that fully prevent withholding are a public account (state is on-chain, so nothing can be withheld), unanimity (threshold == number of approvers, so every approver signs and therefore sees every state transition), or pairing the multisig with a guardian via AuthGuardedMultisig, whose guardian co-signs every transaction and forwards the new state. For a private m-of-n wallet among mutually distrusting approvers, prefer the guarded variant. The create_multisig_wallet helper enforces a related bound: on private accounts it rejects per-procedure thresholds below the default.

Security: growing the signer set does not re-scale overrides

Per-procedure threshold overrides are absolute signature counts, not ratios. Updating the signer set (via the update_signers_and_threshold account procedure) does not re-scale existing overrides: the only cross-check is that each override stays <= num_approvers, which keeps it reachable but never raises it. Growing the approver set therefore silently lowers the effective signing ratio of every override (e.g. a 2-of-2 override becomes 2-of-n). To preserve the intended security level, re-evaluate the affected overrides and, where appropriate, raise them via set_procedure_threshold in the same transaction that grows the signer set.

Security: a raised override is only as strong as the threshold of set_procedure_threshold

An override can demand more signatures for a sensitive operation than the default, but that extra protection is only as strong as the threshold guarding the procedure that can lower it, set_procedure_threshold. That guard is set_procedure_threshold’s own override if one is set, otherwise the default threshold; it is not necessarily the default. A group meeting that guard can strip a stronger override in two transactions: first they lower it, then, in a later transaction, they run the now-cheaper operation. Two transactions are required because the signatures needed are read from the state as of the start of the transaction, so a lowered override only takes effect in the next one.

For example, with 5 signers, a default of 2, set_procedure_threshold left at the default, and a transfer requiring 4: two signers cannot transfer directly, but they can lower the transfer’s override to 2 in one transaction and transfer in the next.

It follows that setting an override higher than the threshold of set_procedure_threshold (which may be the default) is pointless, because the excess signatures can always be removed by that smaller group. To make a raised override hold, raise set_procedure_threshold’s own threshold to at least that value, so undoing the protection costs as many signatures as the operation it guards. AuthMultisig::new enforces this by rejecting any configuration whose override exceeds the threshold of set_procedure_threshold. Note that update_signers_and_threshold can also weaken an override by growing the signer set (see above), so protect it the same way where relevant.

Implementations

impl AuthMultisig

pub const NAME: &'static str = "miden::standards::auth::multisig"

The name of the component.

pub const fn name() -> AccountComponentName

Returns the canonical AccountComponentName of this component.

pub fn code() -> &'static AccountComponentCode

Returns the AccountComponentCode of this component.

pub fn set_procedure_threshold_root() -> AccountProcedureRoot

Returns the procedure root of the set_procedure_threshold account procedure.

pub fn new(config: AuthMultisigConfig) -> Result<AuthMultisig, AccountError>

Creates a new AuthMultisig component from the provided configuration.

Errors

Returns an error if a per-procedure override exceeds the threshold that guards set_procedure_threshold (its own override if set, otherwise the default threshold). Such an override is not enforceable, since a group meeting that lower threshold can strip it via set_procedure_threshold; see the type-level security notes.

pub fn threshold_config_slot() -> &'static StorageSlotName

Returns the StorageSlotName where the threshold configuration is stored.

pub fn approver_public_keys_slot() -> &'static StorageSlotName

Returns the StorageSlotName where the approver public keys are stored.

pub fn approver_scheme_ids_slot() -> &'static StorageSlotName

pub fn executed_transactions_slot() -> &'static StorageSlotName

Returns the StorageSlotName where the executed transactions are stored.

pub fn procedure_thresholds_slot() -> &'static StorageSlotName

Returns the StorageSlotName where the procedure thresholds are stored.

pub fn threshold_config_slot_schema() -> (StorageSlotName, StorageSlotSchema)

Returns the storage slot schema for the threshold configuration slot.

pub fn approver_public_keys_slot_schema() -> (StorageSlotName, StorageSlotSchema)

Returns the storage slot schema for the approver public keys slot.

pub fn approver_auth_scheme_slot_schema() -> (StorageSlotName, StorageSlotSchema)

pub fn executed_transactions_slot_schema() -> (StorageSlotName, StorageSlotSchema)

Returns the storage slot schema for the executed transactions slot.

pub fn procedure_thresholds_slot_schema() -> (StorageSlotName, StorageSlotSchema)

Returns the storage slot schema for the procedure thresholds slot.

pub fn component_metadata() -> AccountComponentMetadata

Returns the AccountComponentMetadata for this component.

Trait Implementations

impl Debug for AuthMultisig

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

Formats the value using the given formatter.

impl From<AuthMultisig> for AccountComponent

fn from(multisig: AuthMultisig) -> AccountComponent

Converts to this type from the input type.