Struct SignerBitmap 

pub struct SignerBitmap { /* private fields */ }

Bit vector of “which validators signed,” sized for a fixed validator set (SPEC §2.10).

Implementations

impl SignerBitmap

pub fn new(validator_count: u32) -> Self

Empty bitmap: all bits zero, sized for validator_count validators.

Panics if validator_count > MAX_VALIDATORS (see MAX_VALIDATORS).

pub fn from_bytes(bytes: &[u8], validator_count: u32) -> Self

Wrap existing bytes (e.g. after deserialization) with a validator count.

Does not copy-truncate bytes to the canonical length; callers should supply ceil(n/8) bytes consistent with validator_count. Self::as_bytes on a value from Self::new always matches.

Panics if validator_count > MAX_VALIDATORS.

pub fn has_signed(&self, index: u32) -> bool

true if validator index has a raised bit and index < validator_count.

Out-of-range indices return false (no panic); short Self::bits tails read as zero.

pub fn set_signed(&mut self, index: u32) -> Result<(), SignerBitmapError>

Sets the bit for index. Error if index >= validator_count (SignerBitmapError::IndexOutOfBounds).

pub fn signer_count(&self) -> u32

Popcount over all stored bytes (ATT-004 spec algorithm).

For bitmaps produced only via Self::new + Self::set_signed, unused high bits in the last byte stay zero, so the count matches “number of validators signed.”

pub fn signing_percentage(&self) -> u64

Integer percentage 0..=100: (signer_count * 100) / validator_count, or 0 if validator_count == 0 (SPEC §2.10 signing_percentage method).

pub fn has_threshold(&self, threshold_pct: u64) -> bool

true iff Self::signing_percentage >= threshold_pct.

pub fn as_bytes(&self) -> &[u8]

Borrow raw bitmap bytes (serialization / hashing helpers).

pub fn validator_count(&self) -> u32

Validator cardinality configured for this bitmap (NORMATIVE field).

pub fn merge(&mut self, other: &SignerBitmap) -> Result<(), SignerBitmapError>

Bitwise OR of other into self (union of signer sets).

ATT-005: Self::validator_count MUST match on both operands; otherwise SignerBitmapError::ValidatorCountMismatch.

Rationale (vs. spec pseudocode)

The ATT-005 snippet zips byte vectors; if self.bits is shorter than other.bits (e.g. odd Self::from_bytes layouts), zip would drop trailing OR contributions. This implementation resizes self.bits to the canonical ceil(validator_count / 8) length, then ORs each index i with other.bits.get(i).unwrap_or(0), matching “combine all signers” intent while staying commutative on well-formed bitmaps.

pub fn signer_indices(&self) -> Vec<u32>

All validator indices with a set bit, in ascending order (0 .. validator_count scan).

ATT-005: Order follows the spec loop (i increasing); callers rely on this for deterministic serialization, tests, and UX (e.g. display). Empty bitmap → empty Vec.

Trait Implementations

impl Clone for SignerBitmap

fn clone(&self) -> SignerBitmap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignerBitmap

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SignerBitmap

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SignerBitmap

fn eq(&self, other: &SignerBitmap) -> 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 SignerBitmap

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SignerBitmap

impl StructuralPartialEq for SignerBitmap