Struct MultiSig 

pub struct MultiSig { /* private fields */ }

Aggregated signature from members of a multisig committee.

BCS

The BCS serialized form for this type is defined by the following ABNF:

multisig-aggregated-signature = (vector multisig-member-signature)
                                u16     ; bitmap
                                multisig-committee

There is also a legacy encoding for this type defined as:

legacy-multisig-aggregated-signature = (vector multisig-member-signature)
                                       roaring-bitmap   ; bitmap
                                       legacy-multisig-committee
roaring-bitmap = bytes  ; where the contents of the bytes are valid
                        ; according to the serialized spec for
                        ; roaring bitmaps

See here for the specification for the serialized format of RoaringBitmaps.

Implementations

impl MultisigAggregatedSignature

pub fn new_unchecked( signatures: Vec<MultisigMemberSignature>, bitmap: u16, committee: MultisigCommittee, ) -> MultisigAggregatedSignature

Construct a MultisigAggregatedSignature from its raw parts without validation.

Unlike Self::new, this performs no checks: the committee is not validated, the bitmap is trusted as-is, and the signatures are not cross-referenced against the committee. The resulting value may be rejected by Self::validate or by on-chain verification.

The caller must ensure that:

• signatures appear in the same order as their corresponding members in committee (e.g. for committee [pk1, pk2, pk3, pk4, pk5], valid signature orderings include [sig1, sig2, sig5] but not [sig2, sig1, sig5]);
• each contributing member’s position is set in bitmap;
• committee itself satisfies MultisigCommittee::validate.

Prefer Self::new when starting from [UserSignature]s; this constructor is intended for deserialization paths and tests where the inputs are already known to be well-formed.

pub fn new( signatures: Vec<UserSignature>, committee: MultisigCommittee, ) -> Result<MultisigAggregatedSignature, MultisigError>

Construct a MultisigAggregatedSignature from a list of [UserSignature]s and a MultisigCommittee.

Compared to Self::new_unchecked, this:

• validates committee via MultisigCommittee::validate;
• converts each [UserSignature] into a MultisigMemberSignature;
• derives the bitmap by locating each signature’s public key in the committee, rejecting duplicates and signatures from non-members;
• rejects empty signature lists and lists longer than the committee;
• rejects signatures that are not in committee order.

signatures must appear in the same order as their corresponding members in committee: for committee [pk1, pk2, pk3, pk4, pk5], [sig1, sig2, sig5] is accepted but [sig2, sig1, sig5] is rejected with [MultisigError::SignaturesOutOfOrder].

pub fn validate(&self) -> Result<(), MultisigError>

Validates the structural integrity of this aggregated signature.

pub fn signatures(&self) -> &[MultisigMemberSignature]

The list of signatures from committee members

pub fn bitmap(&self) -> u16

The bitmap that indicates which committee members provided their signature.

pub fn indices(&self) -> Result<Vec<u8>, MultisigError>

The indices of the committee members that provided their signature, derived from the bitmap.

For example, a bitmap of 0b10110 yields [1, 2, 4]. Returns [MultisigError::InvalidBitmap] if the bitmap has bits set beyond the maximum committee size.

pub fn committee(&self) -> &MultisigCommittee

The committee that authorizes this aggregated signature.

pub fn contains_signature_scheme(&self, scheme: SignatureScheme) -> bool

Returns true if any of the member signatures uses the given signature scheme.

impl MultisigAggregatedSignature

pub fn from_bytes( bytes: impl AsRef<[u8]>, ) -> Result<MultisigAggregatedSignature, SignatureFromBytesError>

Trait Implementations

impl Arbitrary for MultisigAggregatedSignature

Available on crate feature proptest only.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<MultisigAggregatedSignature>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( _args: <MultisigAggregatedSignature as Arbitrary>::Parameters, ) -> <MultisigAggregatedSignature as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl AsRef<[u8]> for MultisigAggregatedSignature

This initialize the underlying bytes representation of MultisigAggregatedSignature. It encodes MultisigAggregatedSignature as the MultiSig flag (0x03) concat with the bcs bytes of MultisigAggregatedSignature i.e. flag || bcs_bytes(multiSig).

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl AuthenticatorTrait for MultiSig

fn verify_claims<T>( &self, intent_message: &IntentMessage<T>, multisig_address: IotaAddress, verify_params: &VerifyParams, ) -> Result<(), IotaError>

where T: Serialize,

impl Clone for MultisigAggregatedSignature

fn clone(&self) -> MultisigAggregatedSignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MultisigAggregatedSignature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MultisigAggregatedSignature

fn deserialize<D>( deserializer: D, ) -> Result<MultisigAggregatedSignature, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<MultisigAggregatedSignature> for GenericSignature

fn from(v: MultiSig) -> GenericSignature

Converts to this type from the input type.

impl FromStr for MultisigAggregatedSignature

type Err = MultisigError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<MultisigAggregatedSignature, <MultisigAggregatedSignature as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for MultisigAggregatedSignature

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MultisigAggregatedSignature

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MultisigAggregatedSignature

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryInto<MultisigAggregatedSignature> for GenericSignature

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<MultiSig, <Self as TryInto<MultiSig>>::Error>

Performs the conversion.

impl Eq for MultisigAggregatedSignature