Struct CommittedMultiSigWires 

pub struct CommittedMultiSigWires {
    pub message: [Wire; 4],
    pub epoch: Wire,
    pub signer_set: [Wire; 8],
    pub signers: Vec<SignerWires>,
}

The wires a committed aggregate occupies.

The message, the epoch and one commitment to the signer set are public. Every key and every signature is private.

So the statement is the same size whatever the number of signers.

Fields

message: [Wire; 4]

epoch: Wire

signer_set: [Wire; 8]

signers: Vec<SignerWires>

Implementations

impl CommittedMultiSigWires

pub fn new(builder: &CircuitBuilder, num_signers: usize) -> Self

Allocates the wires for num_signers signers.

Panics

If there are no signers. A commitment to nothing states nothing. So an empty aggregate is a mistake, not a degenerate case worth supporting.

pub fn populate( &self, w: &mut WitnessFiller<'_>, message: &Message, epoch: u32, signatures: &[(XmssPublicKey, XmssSignature)], )

Populates every wire from a message, an epoch and one key-and-signature pair per signer.

The commitment is computed over the pairs in the order given. Nothing is sorted here.

So a caller that has not sorted gets a statement its own circuit rejects. It never gets a statement about a set it did not mean.

Panics

If the number of pairs is not the number of signers the wires were allocated for.

Trait Implementations

impl Clone for CommittedMultiSigWires

fn clone(&self) -> CommittedMultiSigWires

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommittedMultiSigWires

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

Formats the value using the given formatter.